# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.39
#
# 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
if 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('_gnuradio_swig_py_general', [dirname(__file__)])
        except ImportError:
            import _gnuradio_swig_py_general
            return _gnuradio_swig_py_general
        if fp is not None:
            try:
                _mod = imp.load_module('_gnuradio_swig_py_general', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _gnuradio_swig_py_general = swig_import_helper()
    del swig_import_helper
else:
    import _gnuradio_swig_py_general
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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) or hasattr(self,name):
        self.__dict__[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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x



def nop(*args):
  """nop(size_t sizeof_stream_item) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.nop(*args)

def null_sink(*args):
  """null_sink(size_t sizeof_stream_item) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.null_sink(*args)

def null_source(*args):
  """null_source(size_t sizeof_stream_item) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.null_source(*args)

def head(*args):
  """head(size_t sizeof_stream_item, int nitems) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.head(*args)
class gr_skiphead_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_skiphead)> 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__(self) -> gr_skiphead_sptr
        __init__(self,  p) -> gr_skiphead_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_skiphead_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_skiphead_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_skiphead_sptr_check_topology(self, *args)

gr_skiphead_sptr_swigregister = _gnuradio_swig_py_general.gr_skiphead_sptr_swigregister
gr_skiphead_sptr_swigregister(gr_skiphead_sptr)


def gr_skiphead_block(*args):
  """gr_skiphead_block(gr_skiphead_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_skiphead_block(*args)
gr_skiphead_sptr.block = lambda self: gr_skiphead_block (self)
gr_skiphead_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def skiphead(*args):
  """skiphead(size_t itemsize, size_t nitems_to_skip) -> gr_skiphead_sptr"""
  return _gnuradio_swig_py_general.skiphead(*args)
class gr_quadrature_demod_cf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_quadrature_demod_cf)> 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__(self) -> gr_quadrature_demod_cf_sptr
        __init__(self,  p) -> gr_quadrature_demod_cf_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_quadrature_demod_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_quadrature_demod_cf_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_check_topology(self, *args)

gr_quadrature_demod_cf_sptr_swigregister = _gnuradio_swig_py_general.gr_quadrature_demod_cf_sptr_swigregister
gr_quadrature_demod_cf_sptr_swigregister(gr_quadrature_demod_cf_sptr)


def gr_quadrature_demod_cf_block(*args):
  """gr_quadrature_demod_cf_block(gr_quadrature_demod_cf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_quadrature_demod_cf_block(*args)
gr_quadrature_demod_cf_sptr.block = lambda self: gr_quadrature_demod_cf_block (self)
gr_quadrature_demod_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def quadrature_demod_cf(*args):
  """quadrature_demod_cf(float gain) -> gr_quadrature_demod_cf_sptr"""
  return _gnuradio_swig_py_general.quadrature_demod_cf(*args)
class gr_float_to_complex_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_float_to_complex)> 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__(self) -> gr_float_to_complex_sptr
        __init__(self,  p) -> gr_float_to_complex_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_float_to_complex_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_float_to_complex_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_complex_sptr_check_topology(self, *args)

gr_float_to_complex_sptr_swigregister = _gnuradio_swig_py_general.gr_float_to_complex_sptr_swigregister
gr_float_to_complex_sptr_swigregister(gr_float_to_complex_sptr)

def remez(*args):
  """
    remez(int order, __dummy_5__ bands, __dummy_5__ ampl, __dummy_5__ error_weight, 
        string filter_type = "bandpass", 
        int grid_density = 16) -> __dummy_5__
    remez(int order, __dummy_5__ bands, __dummy_5__ ampl, __dummy_5__ error_weight, 
        string filter_type = "bandpass") -> __dummy_5__
    remez(int order, __dummy_5__ bands, __dummy_5__ ampl, __dummy_5__ error_weight) -> __dummy_5__
    """
  return _gnuradio_swig_py_general.remez(*args)


def gr_float_to_complex_block(*args):
  """gr_float_to_complex_block(gr_float_to_complex_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_float_to_complex_block(*args)
gr_float_to_complex_sptr.block = lambda self: gr_float_to_complex_block (self)
gr_float_to_complex_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def float_to_complex():
  """float_to_complex() -> gr_float_to_complex_sptr"""
  return _gnuradio_swig_py_general.float_to_complex()
class gr_check_counting_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_check_counting_s)> 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__(self) -> gr_check_counting_s_sptr
        __init__(self,  p) -> gr_check_counting_s_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_check_counting_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_check_counting_s_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_check_counting_s_sptr_check_topology(self, *args)

gr_check_counting_s_sptr_swigregister = _gnuradio_swig_py_general.gr_check_counting_s_sptr_swigregister
gr_check_counting_s_sptr_swigregister(gr_check_counting_s_sptr)


def gr_check_counting_s_block(*args):
  """gr_check_counting_s_block(gr_check_counting_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_check_counting_s_block(*args)
gr_check_counting_s_sptr.block = lambda self: gr_check_counting_s_block (self)
gr_check_counting_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_lfsr_32k_source_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_lfsr_32k_source_s)> 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__(self) -> gr_lfsr_32k_source_s_sptr
        __init__(self,  p) -> gr_lfsr_32k_source_s_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_lfsr_32k_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_lfsr_32k_source_s_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_check_topology(self, *args)

gr_lfsr_32k_source_s_sptr_swigregister = _gnuradio_swig_py_general.gr_lfsr_32k_source_s_sptr_swigregister
gr_lfsr_32k_source_s_sptr_swigregister(gr_lfsr_32k_source_s_sptr)

def check_counting_s(do_32bit = False):
  """
    check_counting_s(bool do_32bit = False) -> gr_check_counting_s_sptr
    check_counting_s() -> gr_check_counting_s_sptr
    """
  return _gnuradio_swig_py_general.check_counting_s(do_32bit)


def gr_lfsr_32k_source_s_block(*args):
  """gr_lfsr_32k_source_s_block(gr_lfsr_32k_source_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_lfsr_32k_source_s_block(*args)
gr_lfsr_32k_source_s_sptr.block = lambda self: gr_lfsr_32k_source_s_block (self)
gr_lfsr_32k_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def lfsr_32k_source_s():
  """lfsr_32k_source_s() -> gr_lfsr_32k_source_s_sptr"""
  return _gnuradio_swig_py_general.lfsr_32k_source_s()
class gr_check_lfsr_32k_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_check_lfsr_32k_s)> 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__(self) -> gr_check_lfsr_32k_s_sptr
        __init__(self,  p) -> gr_check_lfsr_32k_s_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_check_lfsr_32k_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_check_lfsr_32k_s_sptr
    __del__ = lambda self : None;
    def ntotal(self):
        """ntotal(self) -> long"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_ntotal(self)

    def nright(self):
        """nright(self) -> long"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_nright(self)

    def runlength(self):
        """runlength(self) -> long"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_runlength(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_check_topology(self, *args)

gr_check_lfsr_32k_s_sptr_swigregister = _gnuradio_swig_py_general.gr_check_lfsr_32k_s_sptr_swigregister
gr_check_lfsr_32k_s_sptr_swigregister(gr_check_lfsr_32k_s_sptr)


def gr_check_lfsr_32k_s_block(*args):
  """gr_check_lfsr_32k_s_block(gr_check_lfsr_32k_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_check_lfsr_32k_s_block(*args)
gr_check_lfsr_32k_s_sptr.block = lambda self: gr_check_lfsr_32k_s_block (self)
gr_check_lfsr_32k_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def check_lfsr_32k_s():
  """check_lfsr_32k_s() -> gr_check_lfsr_32k_s_sptr"""
  return _gnuradio_swig_py_general.check_lfsr_32k_s()
class gr_stream_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_stream_to_vector)> 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__(self) -> gr_stream_to_vector_sptr
        __init__(self,  p) -> gr_stream_to_vector_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_stream_to_vector_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_stream_to_vector_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_vector_sptr_check_topology(self, *args)

gr_stream_to_vector_sptr_swigregister = _gnuradio_swig_py_general.gr_stream_to_vector_sptr_swigregister
gr_stream_to_vector_sptr_swigregister(gr_stream_to_vector_sptr)


def gr_stream_to_vector_block(*args):
  """gr_stream_to_vector_block(gr_stream_to_vector_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_stream_to_vector_block(*args)
gr_stream_to_vector_sptr.block = lambda self: gr_stream_to_vector_block (self)
gr_stream_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def stream_to_vector(*args):
  """stream_to_vector(size_t itemsize, size_t nitems_per_block) -> gr_stream_to_vector_sptr"""
  return _gnuradio_swig_py_general.stream_to_vector(*args)
class gr_vector_to_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_to_stream)> 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__(self) -> gr_vector_to_stream_sptr
        __init__(self,  p) -> gr_vector_to_stream_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_vector_to_stream_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_vector_to_stream_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_stream_sptr_check_topology(self, *args)

gr_vector_to_stream_sptr_swigregister = _gnuradio_swig_py_general.gr_vector_to_stream_sptr_swigregister
gr_vector_to_stream_sptr_swigregister(gr_vector_to_stream_sptr)


def gr_vector_to_stream_block(*args):
  """gr_vector_to_stream_block(gr_vector_to_stream_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_vector_to_stream_block(*args)
gr_vector_to_stream_sptr.block = lambda self: gr_vector_to_stream_block (self)
gr_vector_to_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_to_stream(*args):
  """vector_to_stream(size_t itemsize, size_t nitems_per_block) -> gr_vector_to_stream_sptr"""
  return _gnuradio_swig_py_general.vector_to_stream(*args)
class gr_keep_one_in_n_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_keep_one_in_n)> 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__(self) -> gr_keep_one_in_n_sptr
        __init__(self,  p) -> gr_keep_one_in_n_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_keep_one_in_n_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_keep_one_in_n_sptr
    __del__ = lambda self : None;
    def set_n(self, *args):
        """set_n(self, int n)"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_set_n(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_check_topology(self, *args)

gr_keep_one_in_n_sptr_swigregister = _gnuradio_swig_py_general.gr_keep_one_in_n_sptr_swigregister
gr_keep_one_in_n_sptr_swigregister(gr_keep_one_in_n_sptr)


def gr_keep_one_in_n_block(*args):
  """gr_keep_one_in_n_block(gr_keep_one_in_n_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_keep_one_in_n_block(*args)
gr_keep_one_in_n_sptr.block = lambda self: gr_keep_one_in_n_block (self)
gr_keep_one_in_n_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def keep_one_in_n(*args):
  """keep_one_in_n(size_t itemsize, int n) -> gr_keep_one_in_n_sptr"""
  return _gnuradio_swig_py_general.keep_one_in_n(*args)
class gr_fft_vcc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_fft_vcc)> 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__(self) -> gr_fft_vcc_sptr
        __init__(self,  p) -> gr_fft_vcc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_fft_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_fft_vcc_sptr
    __del__ = lambda self : None;
    def set_window(self, *args):
        """set_window(self, __dummy_4__ window) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_set_window(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vcc_sptr_check_topology(self, *args)

gr_fft_vcc_sptr_swigregister = _gnuradio_swig_py_general.gr_fft_vcc_sptr_swigregister
gr_fft_vcc_sptr_swigregister(gr_fft_vcc_sptr)


def gr_fft_vcc_block(*args):
  """gr_fft_vcc_block(gr_fft_vcc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_fft_vcc_block(*args)
gr_fft_vcc_sptr.block = lambda self: gr_fft_vcc_block (self)
gr_fft_vcc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_fft_vfc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_fft_vfc)> 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__(self) -> gr_fft_vfc_sptr
        __init__(self,  p) -> gr_fft_vfc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_fft_vfc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_fft_vfc_sptr
    __del__ = lambda self : None;
    def set_window(self, *args):
        """set_window(self, __dummy_4__ window) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_set_window(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_fft_vfc_sptr_check_topology(self, *args)

gr_fft_vfc_sptr_swigregister = _gnuradio_swig_py_general.gr_fft_vfc_sptr_swigregister
gr_fft_vfc_sptr_swigregister(gr_fft_vfc_sptr)

def fft_vcc(*args):
  """
    fft_vcc(int fft_size, bool forward, __dummy_4__ window, bool shift = False) -> gr_fft_vcc_sptr
    fft_vcc(int fft_size, bool forward, __dummy_4__ window) -> gr_fft_vcc_sptr
    """
  return _gnuradio_swig_py_general.fft_vcc(*args)


def gr_fft_vfc_block(*args):
  """gr_fft_vfc_block(gr_fft_vfc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_fft_vfc_block(*args)
gr_fft_vfc_sptr.block = lambda self: gr_fft_vfc_block (self)
gr_fft_vfc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def fft_vfc(*args):
  """fft_vfc(int fft_size, bool forward, __dummy_4__ window) -> gr_fft_vfc_sptr"""
  return _gnuradio_swig_py_general.fft_vfc(*args)
class gr_float_to_short_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_float_to_short)> 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__(self) -> gr_float_to_short_sptr
        __init__(self,  p) -> gr_float_to_short_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_float_to_short_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_float_to_short_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_short_sptr_check_topology(self, *args)

gr_float_to_short_sptr_swigregister = _gnuradio_swig_py_general.gr_float_to_short_sptr_swigregister
gr_float_to_short_sptr_swigregister(gr_float_to_short_sptr)


def gr_float_to_short_block(*args):
  """gr_float_to_short_block(gr_float_to_short_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_float_to_short_block(*args)
gr_float_to_short_sptr.block = lambda self: gr_float_to_short_block (self)
gr_float_to_short_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def float_to_short():
  """float_to_short() -> gr_float_to_short_sptr"""
  return _gnuradio_swig_py_general.float_to_short()
class gr_float_to_char_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_float_to_char)> 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__(self) -> gr_float_to_char_sptr
        __init__(self,  p) -> gr_float_to_char_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_float_to_char_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_float_to_char_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_char_sptr_check_topology(self, *args)

gr_float_to_char_sptr_swigregister = _gnuradio_swig_py_general.gr_float_to_char_sptr_swigregister
gr_float_to_char_sptr_swigregister(gr_float_to_char_sptr)


def gr_float_to_char_block(*args):
  """gr_float_to_char_block(gr_float_to_char_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_float_to_char_block(*args)
gr_float_to_char_sptr.block = lambda self: gr_float_to_char_block (self)
gr_float_to_char_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def float_to_char():
  """float_to_char() -> gr_float_to_char_sptr"""
  return _gnuradio_swig_py_general.float_to_char()
class gr_float_to_uchar_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_float_to_uchar)> 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__(self) -> gr_float_to_uchar_sptr
        __init__(self,  p) -> gr_float_to_uchar_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_float_to_uchar_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_float_to_uchar_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_float_to_uchar_sptr_check_topology(self, *args)

gr_float_to_uchar_sptr_swigregister = _gnuradio_swig_py_general.gr_float_to_uchar_sptr_swigregister
gr_float_to_uchar_sptr_swigregister(gr_float_to_uchar_sptr)


def gr_float_to_uchar_block(*args):
  """gr_float_to_uchar_block(gr_float_to_uchar_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_float_to_uchar_block(*args)
gr_float_to_uchar_sptr.block = lambda self: gr_float_to_uchar_block (self)
gr_float_to_uchar_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def float_to_uchar():
  """float_to_uchar() -> gr_float_to_uchar_sptr"""
  return _gnuradio_swig_py_general.float_to_uchar()
class gr_short_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_short_to_float)> 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__(self) -> gr_short_to_float_sptr
        __init__(self,  p) -> gr_short_to_float_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_short_to_float_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_short_to_float_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_short_to_float_sptr_check_topology(self, *args)

gr_short_to_float_sptr_swigregister = _gnuradio_swig_py_general.gr_short_to_float_sptr_swigregister
gr_short_to_float_sptr_swigregister(gr_short_to_float_sptr)


def gr_short_to_float_block(*args):
  """gr_short_to_float_block(gr_short_to_float_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_short_to_float_block(*args)
gr_short_to_float_sptr.block = lambda self: gr_short_to_float_block (self)
gr_short_to_float_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def short_to_float():
  """short_to_float() -> gr_short_to_float_sptr"""
  return _gnuradio_swig_py_general.short_to_float()
class gr_char_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_char_to_float)> 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__(self) -> gr_char_to_float_sptr
        __init__(self,  p) -> gr_char_to_float_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_char_to_float_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_char_to_float_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_char_to_float_sptr_check_topology(self, *args)

gr_char_to_float_sptr_swigregister = _gnuradio_swig_py_general.gr_char_to_float_sptr_swigregister
gr_char_to_float_sptr_swigregister(gr_char_to_float_sptr)


def gr_char_to_float_block(*args):
  """gr_char_to_float_block(gr_char_to_float_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_char_to_float_block(*args)
gr_char_to_float_sptr.block = lambda self: gr_char_to_float_block (self)
gr_char_to_float_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def char_to_float():
  """char_to_float() -> gr_char_to_float_sptr"""
  return _gnuradio_swig_py_general.char_to_float()
class gr_uchar_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_uchar_to_float)> 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__(self) -> gr_uchar_to_float_sptr
        __init__(self,  p) -> gr_uchar_to_float_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_uchar_to_float_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_uchar_to_float_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_uchar_to_float_sptr_check_topology(self, *args)

gr_uchar_to_float_sptr_swigregister = _gnuradio_swig_py_general.gr_uchar_to_float_sptr_swigregister
gr_uchar_to_float_sptr_swigregister(gr_uchar_to_float_sptr)


def gr_uchar_to_float_block(*args):
  """gr_uchar_to_float_block(gr_uchar_to_float_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_uchar_to_float_block(*args)
gr_uchar_to_float_sptr.block = lambda self: gr_uchar_to_float_block (self)
gr_uchar_to_float_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def uchar_to_float():
  """uchar_to_float() -> gr_uchar_to_float_sptr"""
  return _gnuradio_swig_py_general.uchar_to_float()
class gr_frequency_modulator_fc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_frequency_modulator_fc)> 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__(self) -> gr_frequency_modulator_fc_sptr
        __init__(self,  p) -> gr_frequency_modulator_fc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_frequency_modulator_fc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_frequency_modulator_fc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_check_topology(self, *args)

gr_frequency_modulator_fc_sptr_swigregister = _gnuradio_swig_py_general.gr_frequency_modulator_fc_sptr_swigregister
gr_frequency_modulator_fc_sptr_swigregister(gr_frequency_modulator_fc_sptr)


def gr_frequency_modulator_fc_block(*args):
  """gr_frequency_modulator_fc_block(gr_frequency_modulator_fc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_frequency_modulator_fc_block(*args)
gr_frequency_modulator_fc_sptr.block = lambda self: gr_frequency_modulator_fc_block (self)
gr_frequency_modulator_fc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def frequency_modulator_fc(*args):
  """frequency_modulator_fc(double sensitivity) -> gr_frequency_modulator_fc_sptr"""
  return _gnuradio_swig_py_general.frequency_modulator_fc(*args)
class gr_phase_modulator_fc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_phase_modulator_fc)> 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__(self) -> gr_phase_modulator_fc_sptr
        __init__(self,  p) -> gr_phase_modulator_fc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_phase_modulator_fc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_phase_modulator_fc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_check_topology(self, *args)

gr_phase_modulator_fc_sptr_swigregister = _gnuradio_swig_py_general.gr_phase_modulator_fc_sptr_swigregister
gr_phase_modulator_fc_sptr_swigregister(gr_phase_modulator_fc_sptr)


def gr_phase_modulator_fc_block(*args):
  """gr_phase_modulator_fc_block(gr_phase_modulator_fc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_phase_modulator_fc_block(*args)
gr_phase_modulator_fc_sptr.block = lambda self: gr_phase_modulator_fc_block (self)
gr_phase_modulator_fc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def phase_modulator_fc(*args):
  """phase_modulator_fc(double sensitivity) -> gr_phase_modulator_fc_sptr"""
  return _gnuradio_swig_py_general.phase_modulator_fc(*args)
class gr_bytes_to_syms_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_bytes_to_syms)> 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__(self) -> gr_bytes_to_syms_sptr
        __init__(self,  p) -> gr_bytes_to_syms_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_bytes_to_syms_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_bytes_to_syms_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_check_topology(self, *args)

gr_bytes_to_syms_sptr_swigregister = _gnuradio_swig_py_general.gr_bytes_to_syms_sptr_swigregister
gr_bytes_to_syms_sptr_swigregister(gr_bytes_to_syms_sptr)


def gr_bytes_to_syms_block(*args):
  """gr_bytes_to_syms_block(gr_bytes_to_syms_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_bytes_to_syms_block(*args)
gr_bytes_to_syms_sptr.block = lambda self: gr_bytes_to_syms_block (self)
gr_bytes_to_syms_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def bytes_to_syms():
  """bytes_to_syms() -> gr_bytes_to_syms_sptr"""
  return _gnuradio_swig_py_general.bytes_to_syms()
class gr_simple_correlator_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_simple_correlator)> 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__(self) -> gr_simple_correlator_sptr
        __init__(self,  p) -> gr_simple_correlator_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_simple_correlator_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_simple_correlator_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_correlator_sptr_check_topology(self, *args)

gr_simple_correlator_sptr_swigregister = _gnuradio_swig_py_general.gr_simple_correlator_sptr_swigregister
gr_simple_correlator_sptr_swigregister(gr_simple_correlator_sptr)


def gr_simple_correlator_block(*args):
  """gr_simple_correlator_block(gr_simple_correlator_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_simple_correlator_block(*args)
gr_simple_correlator_sptr.block = lambda self: gr_simple_correlator_block (self)
gr_simple_correlator_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def simple_correlator(*args):
  """simple_correlator(int payload_bytesize) -> gr_simple_correlator_sptr"""
  return _gnuradio_swig_py_general.simple_correlator(*args)
class gr_simple_framer_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_simple_framer)> 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__(self) -> gr_simple_framer_sptr
        __init__(self,  p) -> gr_simple_framer_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_simple_framer_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_simple_framer_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_framer_sptr_check_topology(self, *args)

gr_simple_framer_sptr_swigregister = _gnuradio_swig_py_general.gr_simple_framer_sptr_swigregister
gr_simple_framer_sptr_swigregister(gr_simple_framer_sptr)


def gr_simple_framer_block(*args):
  """gr_simple_framer_block(gr_simple_framer_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_simple_framer_block(*args)
gr_simple_framer_sptr.block = lambda self: gr_simple_framer_block (self)
gr_simple_framer_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def simple_framer(*args):
  """simple_framer(int payload_bytesize) -> gr_simple_framer_sptr"""
  return _gnuradio_swig_py_general.simple_framer(*args)
class gr_align_on_samplenumbers_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_align_on_samplenumbers_ss)> 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__(self) -> gr_align_on_samplenumbers_ss_sptr
        __init__(self,  p) -> gr_align_on_samplenumbers_ss_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_align_on_samplenumbers_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_align_on_samplenumbers_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_check_topology(self, *args)

gr_align_on_samplenumbers_ss_sptr_swigregister = _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_sptr_swigregister
gr_align_on_samplenumbers_ss_sptr_swigregister(gr_align_on_samplenumbers_ss_sptr)


def gr_align_on_samplenumbers_ss_block(*args):
  """gr_align_on_samplenumbers_ss_block(gr_align_on_samplenumbers_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_align_on_samplenumbers_ss_block(*args)
gr_align_on_samplenumbers_ss_sptr.block = lambda self: gr_align_on_samplenumbers_ss_block (self)
gr_align_on_samplenumbers_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_float_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_float)> 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__(self) -> gr_complex_to_float_sptr
        __init__(self,  p) -> gr_complex_to_float_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_float_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_float_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_float_sptr_check_topology(self, *args)

gr_complex_to_float_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_float_sptr_swigregister
gr_complex_to_float_sptr_swigregister(gr_complex_to_float_sptr)

def align_on_samplenumbers_ss(nchan = 2, align_interval = 128):
  """
    align_on_samplenumbers_ss(int nchan = 2, int align_interval = 128) -> gr_align_on_samplenumbers_ss_sptr
    align_on_samplenumbers_ss(int nchan = 2) -> gr_align_on_samplenumbers_ss_sptr
    align_on_samplenumbers_ss() -> gr_align_on_samplenumbers_ss_sptr
    """
  return _gnuradio_swig_py_general.align_on_samplenumbers_ss(nchan, align_interval)


def gr_complex_to_float_block(*args):
  """gr_complex_to_float_block(gr_complex_to_float_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_float_block(*args)
gr_complex_to_float_sptr.block = lambda self: gr_complex_to_float_block (self)
gr_complex_to_float_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_real_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_real)> 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__(self) -> gr_complex_to_real_sptr
        __init__(self,  p) -> gr_complex_to_real_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_real_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_real_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_real_sptr_check_topology(self, *args)

gr_complex_to_real_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_real_sptr_swigregister
gr_complex_to_real_sptr_swigregister(gr_complex_to_real_sptr)

def complex_to_float(vlen = 1):
  """
    complex_to_float(unsigned int vlen = 1) -> gr_complex_to_float_sptr
    complex_to_float() -> gr_complex_to_float_sptr
    """
  return _gnuradio_swig_py_general.complex_to_float(vlen)


def gr_complex_to_real_block(*args):
  """gr_complex_to_real_block(gr_complex_to_real_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_real_block(*args)
gr_complex_to_real_sptr.block = lambda self: gr_complex_to_real_block (self)
gr_complex_to_real_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_imag_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_imag)> 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__(self) -> gr_complex_to_imag_sptr
        __init__(self,  p) -> gr_complex_to_imag_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_imag_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_imag_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_imag_sptr_check_topology(self, *args)

gr_complex_to_imag_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_imag_sptr_swigregister
gr_complex_to_imag_sptr_swigregister(gr_complex_to_imag_sptr)

def complex_to_real(vlen = 1):
  """
    complex_to_real(unsigned int vlen = 1) -> gr_complex_to_real_sptr
    complex_to_real() -> gr_complex_to_real_sptr
    """
  return _gnuradio_swig_py_general.complex_to_real(vlen)


def gr_complex_to_imag_block(*args):
  """gr_complex_to_imag_block(gr_complex_to_imag_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_imag_block(*args)
gr_complex_to_imag_sptr.block = lambda self: gr_complex_to_imag_block (self)
gr_complex_to_imag_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_mag_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_mag)> 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__(self) -> gr_complex_to_mag_sptr
        __init__(self,  p) -> gr_complex_to_mag_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_mag_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_mag_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_sptr_check_topology(self, *args)

gr_complex_to_mag_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_mag_sptr_swigregister
gr_complex_to_mag_sptr_swigregister(gr_complex_to_mag_sptr)

def complex_to_imag(vlen = 1):
  """
    complex_to_imag(unsigned int vlen = 1) -> gr_complex_to_imag_sptr
    complex_to_imag() -> gr_complex_to_imag_sptr
    """
  return _gnuradio_swig_py_general.complex_to_imag(vlen)


def gr_complex_to_mag_block(*args):
  """gr_complex_to_mag_block(gr_complex_to_mag_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_mag_block(*args)
gr_complex_to_mag_sptr.block = lambda self: gr_complex_to_mag_block (self)
gr_complex_to_mag_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_mag_squared_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_mag_squared)> 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__(self) -> gr_complex_to_mag_squared_sptr
        __init__(self,  p) -> gr_complex_to_mag_squared_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_mag_squared_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_mag_squared_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_check_topology(self, *args)

gr_complex_to_mag_squared_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_mag_squared_sptr_swigregister
gr_complex_to_mag_squared_sptr_swigregister(gr_complex_to_mag_squared_sptr)

def complex_to_mag(vlen = 1):
  """
    complex_to_mag(unsigned int vlen = 1) -> gr_complex_to_mag_sptr
    complex_to_mag() -> gr_complex_to_mag_sptr
    """
  return _gnuradio_swig_py_general.complex_to_mag(vlen)


def gr_complex_to_mag_squared_block(*args):
  """gr_complex_to_mag_squared_block(gr_complex_to_mag_squared_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_mag_squared_block(*args)
gr_complex_to_mag_squared_sptr.block = lambda self: gr_complex_to_mag_squared_block (self)
gr_complex_to_mag_squared_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_arg_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_arg)> 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__(self) -> gr_complex_to_arg_sptr
        __init__(self,  p) -> gr_complex_to_arg_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_arg_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_arg_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_arg_sptr_check_topology(self, *args)

gr_complex_to_arg_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_arg_sptr_swigregister
gr_complex_to_arg_sptr_swigregister(gr_complex_to_arg_sptr)

def complex_to_mag_squared(vlen = 1):
  """
    complex_to_mag_squared(unsigned int vlen = 1) -> gr_complex_to_mag_squared_sptr
    complex_to_mag_squared() -> gr_complex_to_mag_squared_sptr
    """
  return _gnuradio_swig_py_general.complex_to_mag_squared(vlen)


def gr_complex_to_arg_block(*args):
  """gr_complex_to_arg_block(gr_complex_to_arg_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_arg_block(*args)
gr_complex_to_arg_sptr.block = lambda self: gr_complex_to_arg_block (self)
gr_complex_to_arg_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_complex_to_interleaved_short_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_complex_to_interleaved_short)> 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__(self) -> gr_complex_to_interleaved_short_sptr
        __init__(self,  p) -> gr_complex_to_interleaved_short_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_complex_to_interleaved_short_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_complex_to_interleaved_short_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_check_topology(self, *args)

gr_complex_to_interleaved_short_sptr_swigregister = _gnuradio_swig_py_general.gr_complex_to_interleaved_short_sptr_swigregister
gr_complex_to_interleaved_short_sptr_swigregister(gr_complex_to_interleaved_short_sptr)

def complex_to_arg(vlen = 1):
  """
    complex_to_arg(unsigned int vlen = 1) -> gr_complex_to_arg_sptr
    complex_to_arg() -> gr_complex_to_arg_sptr
    """
  return _gnuradio_swig_py_general.complex_to_arg(vlen)


def gr_complex_to_interleaved_short_block(*args):
  """gr_complex_to_interleaved_short_block(gr_complex_to_interleaved_short_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_complex_to_interleaved_short_block(*args)
gr_complex_to_interleaved_short_sptr.block = lambda self: gr_complex_to_interleaved_short_block (self)
gr_complex_to_interleaved_short_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def complex_to_interleaved_short():
  """complex_to_interleaved_short() -> gr_complex_to_interleaved_short_sptr"""
  return _gnuradio_swig_py_general.complex_to_interleaved_short()
GR_MSB_FIRST = _gnuradio_swig_py_general.GR_MSB_FIRST
GR_LSB_FIRST = _gnuradio_swig_py_general.GR_LSB_FIRST
class gr_interleaved_short_to_complex_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_interleaved_short_to_complex)> 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__(self) -> gr_interleaved_short_to_complex_sptr
        __init__(self,  p) -> gr_interleaved_short_to_complex_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_interleaved_short_to_complex_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_interleaved_short_to_complex_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_check_topology(self, *args)

gr_interleaved_short_to_complex_sptr_swigregister = _gnuradio_swig_py_general.gr_interleaved_short_to_complex_sptr_swigregister
gr_interleaved_short_to_complex_sptr_swigregister(gr_interleaved_short_to_complex_sptr)


def gr_interleaved_short_to_complex_block(*args):
  """gr_interleaved_short_to_complex_block(gr_interleaved_short_to_complex_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_interleaved_short_to_complex_block(*args)
gr_interleaved_short_to_complex_sptr.block = lambda self: gr_interleaved_short_to_complex_block (self)
gr_interleaved_short_to_complex_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def interleaved_short_to_complex():
  """interleaved_short_to_complex() -> gr_interleaved_short_to_complex_sptr"""
  return _gnuradio_swig_py_general.interleaved_short_to_complex()
class firdes(object):
    """Proxy of C++ gr_firdes class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    WIN_HAMMING = _gnuradio_swig_py_general.firdes_WIN_HAMMING
    WIN_HANN = _gnuradio_swig_py_general.firdes_WIN_HANN
    WIN_BLACKMAN = _gnuradio_swig_py_general.firdes_WIN_BLACKMAN
    WIN_RECTANGULAR = _gnuradio_swig_py_general.firdes_WIN_RECTANGULAR
    WIN_KAISER = _gnuradio_swig_py_general.firdes_WIN_KAISER
    def low_pass(*args):
        """
        low_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width, win_type window = WIN_HAMMING, 
            double beta = 6.76) -> __dummy_4__
        low_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width, win_type window = WIN_HAMMING) -> __dummy_4__
        low_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width) -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_low_pass(*args)

    low_pass = staticmethod(low_pass)
    def high_pass(*args):
        """
        high_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width, win_type window = WIN_HAMMING, 
            double beta = 6.76) -> __dummy_4__
        high_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width, win_type window = WIN_HAMMING) -> __dummy_4__
        high_pass(double gain, double sampling_freq, double cutoff_freq, 
            double transition_width) -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_high_pass(*args)

    high_pass = staticmethod(high_pass)
    def band_pass(*args):
        """
        band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING, double beta = 6.76) -> __dummy_4__
        band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING) -> __dummy_4__
        band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width) -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_band_pass(*args)

    band_pass = staticmethod(band_pass)
    def complex_band_pass(*args):
        """
        complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING, double beta = 6.76) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
        complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
        complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
        """
        return _gnuradio_swig_py_general.firdes_complex_band_pass(*args)

    complex_band_pass = staticmethod(complex_band_pass)
    def band_reject(*args):
        """
        band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING, double beta = 6.76) -> __dummy_4__
        band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width, 
            win_type window = WIN_HAMMING) -> __dummy_4__
        band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
            double high_cutoff_freq, double transition_width) -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_band_reject(*args)

    band_reject = staticmethod(band_reject)
    def hilbert(*args):
        """
        hilbert(unsigned int ntaps = 19, win_type windowtype = WIN_RECTANGULAR, 
            double beta = 6.76) -> __dummy_4__
        hilbert(unsigned int ntaps = 19, win_type windowtype = WIN_RECTANGULAR) -> __dummy_4__
        hilbert(unsigned int ntaps = 19) -> __dummy_4__
        hilbert() -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_hilbert(*args)

    hilbert = staticmethod(hilbert)
    def root_raised_cosine(*args):
        """
        root_raised_cosine(double gain, double sampling_freq, double symbol_rate, 
            double alpha, int ntaps) -> __dummy_4__
        """
        return _gnuradio_swig_py_general.firdes_root_raised_cosine(*args)

    root_raised_cosine = staticmethod(root_raised_cosine)
    def gaussian(*args):
        """gaussian(double gain, double spb, double bt, int ntaps) -> __dummy_4__"""
        return _gnuradio_swig_py_general.firdes_gaussian(*args)

    gaussian = staticmethod(gaussian)
    def window(*args):
        """window(win_type type, int ntaps, double beta) -> __dummy_4__"""
        return _gnuradio_swig_py_general.firdes_window(*args)

    window = staticmethod(window)
    def __init__(self): 
        """__init__(self) -> firdes"""
        this = _gnuradio_swig_py_general.new_firdes()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_firdes
    __del__ = lambda self : None;
firdes_swigregister = _gnuradio_swig_py_general.firdes_swigregister
firdes_swigregister(firdes)

def firdes_low_pass(*args):
  """
    low_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width, win_type window = WIN_HAMMING, 
        double beta = 6.76) -> __dummy_4__
    low_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width, win_type window = WIN_HAMMING) -> __dummy_4__
    firdes_low_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width) -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_low_pass(*args)

def firdes_high_pass(*args):
  """
    high_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width, win_type window = WIN_HAMMING, 
        double beta = 6.76) -> __dummy_4__
    high_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width, win_type window = WIN_HAMMING) -> __dummy_4__
    firdes_high_pass(double gain, double sampling_freq, double cutoff_freq, 
        double transition_width) -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_high_pass(*args)

def firdes_band_pass(*args):
  """
    band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING, double beta = 6.76) -> __dummy_4__
    band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING) -> __dummy_4__
    firdes_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width) -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_band_pass(*args)

def firdes_complex_band_pass(*args):
  """
    complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING, double beta = 6.76) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
    complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
    firdes_complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>
    """
  return _gnuradio_swig_py_general.firdes_complex_band_pass(*args)

def firdes_band_reject(*args):
  """
    band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING, double beta = 6.76) -> __dummy_4__
    band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width, 
        win_type window = WIN_HAMMING) -> __dummy_4__
    firdes_band_reject(double gain, double sampling_freq, double low_cutoff_freq, 
        double high_cutoff_freq, double transition_width) -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_band_reject(*args)

def firdes_hilbert(*args):
  """
    hilbert(unsigned int ntaps = 19, win_type windowtype = WIN_RECTANGULAR, 
        double beta = 6.76) -> __dummy_4__
    hilbert(unsigned int ntaps = 19, win_type windowtype = WIN_RECTANGULAR) -> __dummy_4__
    hilbert(unsigned int ntaps = 19) -> __dummy_4__
    firdes_hilbert() -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_hilbert(*args)

def firdes_root_raised_cosine(*args):
  """
    firdes_root_raised_cosine(double gain, double sampling_freq, double symbol_rate, 
        double alpha, int ntaps) -> __dummy_4__
    """
  return _gnuradio_swig_py_general.firdes_root_raised_cosine(*args)

def firdes_gaussian(*args):
  """firdes_gaussian(double gain, double spb, double bt, int ntaps) -> __dummy_4__"""
  return _gnuradio_swig_py_general.firdes_gaussian(*args)

def firdes_window(*args):
  """firdes_window(win_type type, int ntaps, double beta) -> __dummy_4__"""
  return _gnuradio_swig_py_general.firdes_window(*args)

class gr_interleave_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_interleave)> 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__(self) -> gr_interleave_sptr
        __init__(self,  p) -> gr_interleave_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_interleave_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_interleave_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_interleave_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_interleave_sptr_check_topology(self, *args)

gr_interleave_sptr_swigregister = _gnuradio_swig_py_general.gr_interleave_sptr_swigregister
gr_interleave_sptr_swigregister(gr_interleave_sptr)


def gr_interleave_block(*args):
  """gr_interleave_block(gr_interleave_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_interleave_block(*args)
gr_interleave_sptr.block = lambda self: gr_interleave_block (self)
gr_interleave_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def interleave(*args):
  """interleave(size_t itemsize) -> gr_interleave_sptr"""
  return _gnuradio_swig_py_general.interleave(*args)
class gr_deinterleave_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_deinterleave)> 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__(self) -> gr_deinterleave_sptr
        __init__(self,  p) -> gr_deinterleave_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_deinterleave_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_deinterleave_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_deinterleave_sptr_check_topology(self, *args)

gr_deinterleave_sptr_swigregister = _gnuradio_swig_py_general.gr_deinterleave_sptr_swigregister
gr_deinterleave_sptr_swigregister(gr_deinterleave_sptr)


def gr_deinterleave_block(*args):
  """gr_deinterleave_block(gr_deinterleave_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_deinterleave_block(*args)
gr_deinterleave_sptr.block = lambda self: gr_deinterleave_block (self)
gr_deinterleave_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def deinterleave(*args):
  """deinterleave(size_t itemsize) -> gr_deinterleave_sptr"""
  return _gnuradio_swig_py_general.deinterleave(*args)
class gr_delay_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_delay)> 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__(self) -> gr_delay_sptr
        __init__(self,  p) -> gr_delay_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_delay_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_delay_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_delay_sptr
    __del__ = lambda self : None;
    def delay(self):
        """delay(self) -> int"""
        return _gnuradio_swig_py_general.gr_delay_sptr_delay(self)

    def set_delay(self, *args):
        """set_delay(self, int delay)"""
        return _gnuradio_swig_py_general.gr_delay_sptr_set_delay(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_delay_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_delay_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_delay_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_delay_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_delay_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_delay_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_delay_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_delay_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_delay_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_delay_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_delay_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_delay_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_delay_sptr_check_topology(self, *args)

gr_delay_sptr_swigregister = _gnuradio_swig_py_general.gr_delay_sptr_swigregister
gr_delay_sptr_swigregister(gr_delay_sptr)


def gr_delay_block(*args):
  """gr_delay_block(gr_delay_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_delay_block(*args)
gr_delay_sptr.block = lambda self: gr_delay_block (self)
gr_delay_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def delay(*args):
  """delay(size_t itemsize, int delay) -> gr_delay_sptr"""
  return _gnuradio_swig_py_general.delay(*args)
class gr_simple_squelch_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_simple_squelch_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__(self) -> gr_simple_squelch_cc_sptr
        __init__(self,  p) -> gr_simple_squelch_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_simple_squelch_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_simple_squelch_cc_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_unmuted(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_set_alpha(self, *args)

    def set_threshold(self, *args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_set_threshold(self, *args)

    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_threshold(self)

    def squelch_range(self):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_squelch_range(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_check_topology(self, *args)

gr_simple_squelch_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_simple_squelch_cc_sptr_swigregister
gr_simple_squelch_cc_sptr_swigregister(gr_simple_squelch_cc_sptr)


def gr_simple_squelch_cc_block(*args):
  """gr_simple_squelch_cc_block(gr_simple_squelch_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_simple_squelch_cc_block(*args)
gr_simple_squelch_cc_sptr.block = lambda self: gr_simple_squelch_cc_block (self)
gr_simple_squelch_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_agc_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_agc_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__(self) -> gr_agc_ff_sptr
        __init__(self,  p) -> gr_agc_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_agc_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_agc_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_ff_sptr_check_topology(self, *args)

gr_agc_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_agc_ff_sptr_swigregister
gr_agc_ff_sptr_swigregister(gr_agc_ff_sptr)

def simple_squelch_cc(*args):
  """
    simple_squelch_cc(double threshold_db, double alpha = 0.0001) -> gr_simple_squelch_cc_sptr
    simple_squelch_cc(double threshold_db) -> gr_simple_squelch_cc_sptr
    """
  return _gnuradio_swig_py_general.simple_squelch_cc(*args)


def gr_agc_ff_block(*args):
  """gr_agc_ff_block(gr_agc_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_agc_ff_block(*args)
gr_agc_ff_sptr.block = lambda self: gr_agc_ff_block (self)
gr_agc_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gri_agc_ff(object):
    """Proxy of C++ gri_agc_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, rate = 1e-4, reference = 1.0, gain = 1.0, max_gain = 0.0): 
        """
        __init__(self, float rate = 1e-4, float reference = 1.0, float gain = 1.0, 
            float max_gain = 0.0) -> gri_agc_ff
        __init__(self, float rate = 1e-4, float reference = 1.0, float gain = 1.0) -> gri_agc_ff
        __init__(self, float rate = 1e-4, float reference = 1.0) -> gri_agc_ff
        __init__(self, float rate = 1e-4) -> gri_agc_ff
        __init__(self) -> gri_agc_ff
        """
        this = _gnuradio_swig_py_general.new_gri_agc_ff(rate, reference, gain, max_gain)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_gri_agc_ff
    __del__ = lambda self : None;
gri_agc_ff_swigregister = _gnuradio_swig_py_general.gri_agc_ff_swigregister
gri_agc_ff_swigregister(gri_agc_ff)

class gr_agc_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_agc_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__(self) -> gr_agc_cc_sptr
        __init__(self,  p) -> gr_agc_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_agc_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_agc_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_check_topology(self, *args)

    def rate(self):
        """rate(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_rate(self)

    def reference(self):
        """reference(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_reference(self)

    def gain(self):
        """gain(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_gain(self)

    def max_gain(self):
        """max_gain(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc_cc_sptr_max_gain(self)

gr_agc_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_agc_cc_sptr_swigregister
gr_agc_cc_sptr_swigregister(gr_agc_cc_sptr)

def agc_ff(rate = 1e-4, reference = 1.0, gain = 1.0, max_gain = 0.0):
  """
    agc_ff(float rate = 1e-4, float reference = 1.0, float gain = 1.0, 
        float max_gain = 0.0) -> gr_agc_ff_sptr
    agc_ff(float rate = 1e-4, float reference = 1.0, float gain = 1.0) -> gr_agc_ff_sptr
    agc_ff(float rate = 1e-4, float reference = 1.0) -> gr_agc_ff_sptr
    agc_ff(float rate = 1e-4) -> gr_agc_ff_sptr
    agc_ff() -> gr_agc_ff_sptr
    """
  return _gnuradio_swig_py_general.agc_ff(rate, reference, gain, max_gain)


def gr_agc_cc_block(*args):
  """gr_agc_cc_block(gr_agc_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_agc_cc_block(*args)
gr_agc_cc_sptr.block = lambda self: gr_agc_cc_block (self)
gr_agc_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gri_agc_cc(object):
    """Proxy of C++ gri_agc_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, rate = 1e-4, reference = 1.0, gain = 1.0, max_gain = 0.0): 
        """
        __init__(self, float rate = 1e-4, float reference = 1.0, float gain = 1.0, 
            float max_gain = 0.0) -> gri_agc_cc
        __init__(self, float rate = 1e-4, float reference = 1.0, float gain = 1.0) -> gri_agc_cc
        __init__(self, float rate = 1e-4, float reference = 1.0) -> gri_agc_cc
        __init__(self, float rate = 1e-4) -> gri_agc_cc
        __init__(self) -> gri_agc_cc
        """
        this = _gnuradio_swig_py_general.new_gri_agc_cc(rate, reference, gain, max_gain)
        try: self.this.append(this)
        except: self.this = this
    def rate(self):
        """rate(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc_cc_rate(self)

    def reference(self):
        """reference(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc_cc_reference(self)

    def gain(self):
        """gain(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc_cc_gain(self)

    def max_gain(self):
        """max_gain(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc_cc_max_gain(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gri_agc_cc
    __del__ = lambda self : None;
gri_agc_cc_swigregister = _gnuradio_swig_py_general.gri_agc_cc_swigregister
gri_agc_cc_swigregister(gri_agc_cc)

class gr_agc2_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_agc2_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__(self) -> gr_agc2_ff_sptr
        __init__(self,  p) -> gr_agc2_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_agc2_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_agc2_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_ff_sptr_check_topology(self, *args)

gr_agc2_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_agc2_ff_sptr_swigregister
gr_agc2_ff_sptr_swigregister(gr_agc2_ff_sptr)

def agc_cc(rate = 1e-4, reference = 1.0, gain = 1.0, max_gain = 0.0):
  """
    agc_cc(float rate = 1e-4, float reference = 1.0, float gain = 1.0, 
        float max_gain = 0.0) -> gr_agc_cc_sptr
    agc_cc(float rate = 1e-4, float reference = 1.0, float gain = 1.0) -> gr_agc_cc_sptr
    agc_cc(float rate = 1e-4, float reference = 1.0) -> gr_agc_cc_sptr
    agc_cc(float rate = 1e-4) -> gr_agc_cc_sptr
    agc_cc() -> gr_agc_cc_sptr
    """
  return _gnuradio_swig_py_general.agc_cc(rate, reference, gain, max_gain)


def gr_agc2_ff_block(*args):
  """gr_agc2_ff_block(gr_agc2_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_agc2_ff_block(*args)
gr_agc2_ff_sptr.block = lambda self: gr_agc2_ff_block (self)
gr_agc2_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gri_agc2_ff(object):
    """Proxy of C++ gri_agc2_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, attack_rate = 1e-1, decay_rate = 1e-2, reference = 1.0, 
    gain = 1.0, max_gain = 0.0): 
        """
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0, float gain = 1.0, float max_gain = 0.0) -> gri_agc2_ff
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0, float gain = 1.0) -> gri_agc2_ff
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0) -> gri_agc2_ff
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2) -> gri_agc2_ff
        __init__(self, float attack_rate = 1e-1) -> gri_agc2_ff
        __init__(self) -> gri_agc2_ff
        """
        this = _gnuradio_swig_py_general.new_gri_agc2_ff(attack_rate, decay_rate, reference, gain, max_gain)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_gri_agc2_ff
    __del__ = lambda self : None;
gri_agc2_ff_swigregister = _gnuradio_swig_py_general.gri_agc2_ff_swigregister
gri_agc2_ff_swigregister(gri_agc2_ff)

class gr_agc2_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_agc2_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__(self) -> gr_agc2_cc_sptr
        __init__(self,  p) -> gr_agc2_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_agc2_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_agc2_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_check_topology(self, *args)

    def decay_rate(self):
        """decay_rate(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_decay_rate(self)

    def attack_rate(self):
        """attack_rate(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_attack_rate(self)

    def reference(self):
        """reference(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_reference(self)

    def gain(self):
        """gain(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_gain(self)

    def max_gain(self):
        """max_gain(self) -> float"""
        return _gnuradio_swig_py_general.gr_agc2_cc_sptr_max_gain(self)

gr_agc2_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_agc2_cc_sptr_swigregister
gr_agc2_cc_sptr_swigregister(gr_agc2_cc_sptr)

def agc2_ff(attack_rate = 1e-1, decay_rate = 1e-2, reference = 1.0, 
    gain = 1.0, max_gain = 0.0):
  """
    agc2_ff(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0, float gain = 1.0, float max_gain = 0.0) -> gr_agc2_ff_sptr
    agc2_ff(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0, float gain = 1.0) -> gr_agc2_ff_sptr
    agc2_ff(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0) -> gr_agc2_ff_sptr
    agc2_ff(float attack_rate = 1e-1, float decay_rate = 1e-2) -> gr_agc2_ff_sptr
    agc2_ff(float attack_rate = 1e-1) -> gr_agc2_ff_sptr
    agc2_ff() -> gr_agc2_ff_sptr
    """
  return _gnuradio_swig_py_general.agc2_ff(attack_rate, decay_rate, reference, gain, max_gain)


def gr_agc2_cc_block(*args):
  """gr_agc2_cc_block(gr_agc2_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_agc2_cc_block(*args)
gr_agc2_cc_sptr.block = lambda self: gr_agc2_cc_block (self)
gr_agc2_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gri_agc2_cc(object):
    """Proxy of C++ gri_agc2_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, attack_rate = 1e-1, decay_rate = 1e-2, reference = 1.0, 
    gain = 1.0, max_gain = 0.0): 
        """
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0, float gain = 1.0, float max_gain = 0.0) -> gri_agc2_cc
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0, float gain = 1.0) -> gri_agc2_cc
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2, 
            float reference = 1.0) -> gri_agc2_cc
        __init__(self, float attack_rate = 1e-1, float decay_rate = 1e-2) -> gri_agc2_cc
        __init__(self, float attack_rate = 1e-1) -> gri_agc2_cc
        __init__(self) -> gri_agc2_cc
        """
        this = _gnuradio_swig_py_general.new_gri_agc2_cc(attack_rate, decay_rate, reference, gain, max_gain)
        try: self.this.append(this)
        except: self.this = this
    def decay_rate(self):
        """decay_rate(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc2_cc_decay_rate(self)

    def attack_rate(self):
        """attack_rate(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc2_cc_attack_rate(self)

    def reference(self):
        """reference(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc2_cc_reference(self)

    def gain(self):
        """gain(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc2_cc_gain(self)

    def max_gain(self):
        """max_gain(self) -> float"""
        return _gnuradio_swig_py_general.gri_agc2_cc_max_gain(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gri_agc2_cc
    __del__ = lambda self : None;
gri_agc2_cc_swigregister = _gnuradio_swig_py_general.gri_agc2_cc_swigregister
gri_agc2_cc_swigregister(gri_agc2_cc)

class gr_rms_cf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_rms_cf)> 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__(self) -> gr_rms_cf_sptr
        __init__(self,  p) -> gr_rms_cf_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_rms_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_rms_cf_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_unmuted(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_set_alpha(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_cf_sptr_check_topology(self, *args)

gr_rms_cf_sptr_swigregister = _gnuradio_swig_py_general.gr_rms_cf_sptr_swigregister
gr_rms_cf_sptr_swigregister(gr_rms_cf_sptr)

def agc2_cc(attack_rate = 1e-1, decay_rate = 1e-2, reference = 1.0, 
    gain = 1.0, max_gain = 0.0):
  """
    agc2_cc(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0, float gain = 1.0, float max_gain = 0.0) -> gr_agc2_cc_sptr
    agc2_cc(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0, float gain = 1.0) -> gr_agc2_cc_sptr
    agc2_cc(float attack_rate = 1e-1, float decay_rate = 1e-2, 
        float reference = 1.0) -> gr_agc2_cc_sptr
    agc2_cc(float attack_rate = 1e-1, float decay_rate = 1e-2) -> gr_agc2_cc_sptr
    agc2_cc(float attack_rate = 1e-1) -> gr_agc2_cc_sptr
    agc2_cc() -> gr_agc2_cc_sptr
    """
  return _gnuradio_swig_py_general.agc2_cc(attack_rate, decay_rate, reference, gain, max_gain)


def gr_rms_cf_block(*args):
  """gr_rms_cf_block(gr_rms_cf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_rms_cf_block(*args)
gr_rms_cf_sptr.block = lambda self: gr_rms_cf_block (self)
gr_rms_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_rms_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_rms_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__(self) -> gr_rms_ff_sptr
        __init__(self,  p) -> gr_rms_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_rms_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_rms_ff_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_unmuted(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_set_alpha(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_rms_ff_sptr_check_topology(self, *args)

gr_rms_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_rms_ff_sptr_swigregister
gr_rms_ff_sptr_swigregister(gr_rms_ff_sptr)

def rms_cf(alpha = 0.0001):
  """
    rms_cf(double alpha = 0.0001) -> gr_rms_cf_sptr
    rms_cf() -> gr_rms_cf_sptr
    """
  return _gnuradio_swig_py_general.rms_cf(alpha)


def gr_rms_ff_block(*args):
  """gr_rms_ff_block(gr_rms_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_rms_ff_block(*args)
gr_rms_ff_sptr.block = lambda self: gr_rms_ff_block (self)
gr_rms_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_nlog10_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_nlog10_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__(self) -> gr_nlog10_ff_sptr
        __init__(self,  p) -> gr_nlog10_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_nlog10_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_nlog10_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_nlog10_ff_sptr_check_topology(self, *args)

gr_nlog10_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_nlog10_ff_sptr_swigregister
gr_nlog10_ff_sptr_swigregister(gr_nlog10_ff_sptr)

def rms_ff(alpha = 0.0001):
  """
    rms_ff(double alpha = 0.0001) -> gr_rms_ff_sptr
    rms_ff() -> gr_rms_ff_sptr
    """
  return _gnuradio_swig_py_general.rms_ff(alpha)


def gr_nlog10_ff_block(*args):
  """gr_nlog10_ff_block(gr_nlog10_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_nlog10_ff_block(*args)
gr_nlog10_ff_sptr.block = lambda self: gr_nlog10_ff_block (self)
gr_nlog10_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_fake_channel_encoder_pp_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_fake_channel_encoder_pp)> 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__(self) -> gr_fake_channel_encoder_pp_sptr
        __init__(self,  p) -> gr_fake_channel_encoder_pp_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_fake_channel_encoder_pp_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_fake_channel_encoder_pp_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_check_topology(self, *args)

gr_fake_channel_encoder_pp_sptr_swigregister = _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_sptr_swigregister
gr_fake_channel_encoder_pp_sptr_swigregister(gr_fake_channel_encoder_pp_sptr)

def nlog10_ff(n = 1.0, vlen = 1, k = 0):
  """
    nlog10_ff(float n = 1.0, unsigned int vlen = 1, float k = 0) -> gr_nlog10_ff_sptr
    nlog10_ff(float n = 1.0, unsigned int vlen = 1) -> gr_nlog10_ff_sptr
    nlog10_ff(float n = 1.0) -> gr_nlog10_ff_sptr
    nlog10_ff() -> gr_nlog10_ff_sptr
    """
  return _gnuradio_swig_py_general.nlog10_ff(n, vlen, k)


def gr_fake_channel_encoder_pp_block(*args):
  """gr_fake_channel_encoder_pp_block(gr_fake_channel_encoder_pp_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_fake_channel_encoder_pp_block(*args)
gr_fake_channel_encoder_pp_sptr.block = lambda self: gr_fake_channel_encoder_pp_block (self)
gr_fake_channel_encoder_pp_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def fake_channel_encoder_pp(*args):
  """fake_channel_encoder_pp(int input_vlen, int output_vlen) -> gr_fake_channel_encoder_pp_sptr"""
  return _gnuradio_swig_py_general.fake_channel_encoder_pp(*args)
class gr_fake_channel_decoder_pp_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_fake_channel_decoder_pp)> 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__(self) -> gr_fake_channel_decoder_pp_sptr
        __init__(self,  p) -> gr_fake_channel_decoder_pp_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_fake_channel_decoder_pp_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_fake_channel_decoder_pp_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_check_topology(self, *args)

gr_fake_channel_decoder_pp_sptr_swigregister = _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_sptr_swigregister
gr_fake_channel_decoder_pp_sptr_swigregister(gr_fake_channel_decoder_pp_sptr)


def gr_fake_channel_decoder_pp_block(*args):
  """gr_fake_channel_decoder_pp_block(gr_fake_channel_decoder_pp_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_fake_channel_decoder_pp_block(*args)
gr_fake_channel_decoder_pp_sptr.block = lambda self: gr_fake_channel_decoder_pp_block (self)
gr_fake_channel_decoder_pp_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def fake_channel_decoder_pp(*args):
  """fake_channel_decoder_pp(int input_vlen, int output_vlen) -> gr_fake_channel_decoder_pp_sptr"""
  return _gnuradio_swig_py_general.fake_channel_decoder_pp(*args)
class gr_throttle_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_throttle)> 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__(self) -> gr_throttle_sptr
        __init__(self,  p) -> gr_throttle_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_throttle_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_throttle_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_throttle_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_throttle_sptr_check_topology(self, *args)

gr_throttle_sptr_swigregister = _gnuradio_swig_py_general.gr_throttle_sptr_swigregister
gr_throttle_sptr_swigregister(gr_throttle_sptr)


def gr_throttle_block(*args):
  """gr_throttle_block(gr_throttle_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_throttle_block(*args)
gr_throttle_sptr.block = lambda self: gr_throttle_block (self)
gr_throttle_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def throttle(*args):
  """throttle(size_t itemsize, double samples_per_sec) -> gr_throttle_sptr"""
  return _gnuradio_swig_py_general.throttle(*args)
class gr_mpsk_receiver_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_mpsk_receiver_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__(self) -> gr_mpsk_receiver_cc_sptr
        __init__(self,  p) -> gr_mpsk_receiver_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_mpsk_receiver_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_mpsk_receiver_cc_sptr
    __del__ = lambda self : None;
    def mu(self):
        """mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_mu(self)

    def omega(self):
        """omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_omega(self)

    def gain_mu(self):
        """gain_mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_gain_mu(self)

    def gain_omega(self):
        """gain_omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_gain_omega(self)

    def set_mu(self, *args):
        """set_mu(self, float mu)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_mu(self, *args)

    def set_omega(self, *args):
        """set_omega(self, float omega)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_omega(self, *args)

    def set_gain_mu(self, *args):
        """set_gain_mu(self, float gain_mu)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_gain_mu(self, *args)

    def set_gain_omega(self, *args):
        """set_gain_omega(self, float gain_omega)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_gain_omega(self, *args)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_alpha(self)

    def beta(self):
        """beta(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_beta(self)

    def freq(self):
        """freq(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_freq(self)

    def phase(self):
        """phase(self) -> float"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_phase(self)

    def set_alpha(self, *args):
        """set_alpha(self, float alpha)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_alpha(self, *args)

    def set_beta(self, *args):
        """set_beta(self, float beta)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_beta(self, *args)

    def set_freq(self, *args):
        """set_freq(self, float freq)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_freq(self, *args)

    def set_phase(self, *args):
        """set_phase(self, float phase)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_phase(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_check_topology(self, *args)

gr_mpsk_receiver_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_mpsk_receiver_cc_sptr_swigregister
gr_mpsk_receiver_cc_sptr_swigregister(gr_mpsk_receiver_cc_sptr)


def gr_mpsk_receiver_cc_block(*args):
  """gr_mpsk_receiver_cc_block(gr_mpsk_receiver_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_mpsk_receiver_cc_block(*args)
gr_mpsk_receiver_cc_sptr.block = lambda self: gr_mpsk_receiver_cc_block (self)
gr_mpsk_receiver_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def mpsk_receiver_cc(*args):
  """
    mpsk_receiver_cc(unsigned int M, float theta, float alpha, float beta, 
        float fmin, float fmax, float mu, float gain_mu, 
        float omega, float gain_omega, float omega_rel) -> gr_mpsk_receiver_cc_sptr
    """
  return _gnuradio_swig_py_general.mpsk_receiver_cc(*args)
class gr_stream_mux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_stream_mux)> 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__(self) -> gr_stream_mux_sptr
        __init__(self,  p) -> gr_stream_mux_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_stream_mux_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_stream_mux_sptr
    __del__ = lambda self : None;
    def general_work(self, *args):
        """
        general_work(self, int noutput_items, gr_vector_int ninput_items, gr_vector_const_void_star input_items, 
            gr_vector_void_star output_items) -> int
        """
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_general_work(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_mux_sptr_check_topology(self, *args)

gr_stream_mux_sptr_swigregister = _gnuradio_swig_py_general.gr_stream_mux_sptr_swigregister
gr_stream_mux_sptr_swigregister(gr_stream_mux_sptr)


def gr_stream_mux_block(*args):
  """gr_stream_mux_block(gr_stream_mux_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_stream_mux_block(*args)
gr_stream_mux_sptr.block = lambda self: gr_stream_mux_block (self)
gr_stream_mux_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def stream_mux(*args):
  """stream_mux(size_t itemsize, __dummy_3__ lengths) -> gr_stream_mux_sptr"""
  return _gnuradio_swig_py_general.stream_mux(*args)
class gr_stream_to_streams_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_stream_to_streams)> 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__(self) -> gr_stream_to_streams_sptr
        __init__(self,  p) -> gr_stream_to_streams_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_stream_to_streams_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_stream_to_streams_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_stream_to_streams_sptr_check_topology(self, *args)

gr_stream_to_streams_sptr_swigregister = _gnuradio_swig_py_general.gr_stream_to_streams_sptr_swigregister
gr_stream_to_streams_sptr_swigregister(gr_stream_to_streams_sptr)


def gr_stream_to_streams_block(*args):
  """gr_stream_to_streams_block(gr_stream_to_streams_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_stream_to_streams_block(*args)
gr_stream_to_streams_sptr.block = lambda self: gr_stream_to_streams_block (self)
gr_stream_to_streams_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def stream_to_streams(*args):
  """stream_to_streams(size_t itemsize, size_t nstreams) -> gr_stream_to_streams_sptr"""
  return _gnuradio_swig_py_general.stream_to_streams(*args)
class gr_streams_to_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_streams_to_stream)> 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__(self) -> gr_streams_to_stream_sptr
        __init__(self,  p) -> gr_streams_to_stream_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_streams_to_stream_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_streams_to_stream_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_stream_sptr_check_topology(self, *args)

gr_streams_to_stream_sptr_swigregister = _gnuradio_swig_py_general.gr_streams_to_stream_sptr_swigregister
gr_streams_to_stream_sptr_swigregister(gr_streams_to_stream_sptr)


def gr_streams_to_stream_block(*args):
  """gr_streams_to_stream_block(gr_streams_to_stream_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_streams_to_stream_block(*args)
gr_streams_to_stream_sptr.block = lambda self: gr_streams_to_stream_block (self)
gr_streams_to_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def streams_to_stream(*args):
  """streams_to_stream(size_t itemsize, size_t nstreams) -> gr_streams_to_stream_sptr"""
  return _gnuradio_swig_py_general.streams_to_stream(*args)
class gr_streams_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_streams_to_vector)> 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__(self) -> gr_streams_to_vector_sptr
        __init__(self,  p) -> gr_streams_to_vector_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_streams_to_vector_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_streams_to_vector_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_streams_to_vector_sptr_check_topology(self, *args)

gr_streams_to_vector_sptr_swigregister = _gnuradio_swig_py_general.gr_streams_to_vector_sptr_swigregister
gr_streams_to_vector_sptr_swigregister(gr_streams_to_vector_sptr)


def gr_streams_to_vector_block(*args):
  """gr_streams_to_vector_block(gr_streams_to_vector_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_streams_to_vector_block(*args)
gr_streams_to_vector_sptr.block = lambda self: gr_streams_to_vector_block (self)
gr_streams_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def streams_to_vector(*args):
  """streams_to_vector(size_t itemsize, size_t nstreams) -> gr_streams_to_vector_sptr"""
  return _gnuradio_swig_py_general.streams_to_vector(*args)
class gr_vector_to_streams_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_to_streams)> 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__(self) -> gr_vector_to_streams_sptr
        __init__(self,  p) -> gr_vector_to_streams_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_vector_to_streams_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_vector_to_streams_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_vector_to_streams_sptr_check_topology(self, *args)

gr_vector_to_streams_sptr_swigregister = _gnuradio_swig_py_general.gr_vector_to_streams_sptr_swigregister
gr_vector_to_streams_sptr_swigregister(gr_vector_to_streams_sptr)


def gr_vector_to_streams_block(*args):
  """gr_vector_to_streams_block(gr_vector_to_streams_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_vector_to_streams_block(*args)
gr_vector_to_streams_sptr.block = lambda self: gr_vector_to_streams_block (self)
gr_vector_to_streams_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_to_streams(*args):
  """vector_to_streams(size_t itemsize, size_t nstreams) -> gr_vector_to_streams_sptr"""
  return _gnuradio_swig_py_general.vector_to_streams(*args)
class gr_conjugate_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_conjugate_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__(self) -> gr_conjugate_cc_sptr
        __init__(self,  p) -> gr_conjugate_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_conjugate_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_conjugate_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_conjugate_cc_sptr_check_topology(self, *args)

gr_conjugate_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_conjugate_cc_sptr_swigregister
gr_conjugate_cc_sptr_swigregister(gr_conjugate_cc_sptr)


def gr_conjugate_cc_block(*args):
  """gr_conjugate_cc_block(gr_conjugate_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_conjugate_cc_block(*args)
gr_conjugate_cc_sptr.block = lambda self: gr_conjugate_cc_block (self)
gr_conjugate_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def conjugate_cc():
  """conjugate_cc() -> gr_conjugate_cc_sptr"""
  return _gnuradio_swig_py_general.conjugate_cc()
class gr_vco_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vco_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__(self) -> gr_vco_f_sptr
        __init__(self,  p) -> gr_vco_f_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_vco_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_vco_f_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_vco_f_sptr_check_topology(self, *args)

gr_vco_f_sptr_swigregister = _gnuradio_swig_py_general.gr_vco_f_sptr_swigregister
gr_vco_f_sptr_swigregister(gr_vco_f_sptr)


def gr_vco_f_block(*args):
  """gr_vco_f_block(gr_vco_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_vco_f_block(*args)
gr_vco_f_sptr.block = lambda self: gr_vco_f_block (self)
gr_vco_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vco_f(*args):
  """vco_f(double sampling_rate, double sensitivity, double amplitude) -> gr_vco_f_sptr"""
  return _gnuradio_swig_py_general.vco_f(*args)

def update_crc32(*args):
  """update_crc32(unsigned int crc, string buf) -> unsigned int"""
  return _gnuradio_swig_py_general.update_crc32(*args)

def crc32(*args):
  """crc32(string buf) -> unsigned int"""
  return _gnuradio_swig_py_general.crc32(*args)
class gr_threshold_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_threshold_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__(self) -> gr_threshold_ff_sptr
        __init__(self,  p) -> gr_threshold_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_threshold_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_threshold_ff_sptr
    __del__ = lambda self : None;
    def lo(self):
        """lo(self) -> float"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_lo(self)

    def set_lo(self, *args):
        """set_lo(self, float lo)"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_set_lo(self, *args)

    def hi(self):
        """hi(self) -> float"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_hi(self)

    def set_hi(self, *args):
        """set_hi(self, float hi)"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_set_hi(self, *args)

    def last_state(self):
        """last_state(self) -> float"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_last_state(self)

    def set_last_state(self, *args):
        """set_last_state(self, float last_state)"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_set_last_state(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_threshold_ff_sptr_check_topology(self, *args)

gr_threshold_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_threshold_ff_sptr_swigregister
gr_threshold_ff_sptr_swigregister(gr_threshold_ff_sptr)


def gr_threshold_ff_block(*args):
  """gr_threshold_ff_block(gr_threshold_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_threshold_ff_block(*args)
gr_threshold_ff_sptr.block = lambda self: gr_threshold_ff_block (self)
gr_threshold_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_clock_recovery_mm_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_clock_recovery_mm_ff_sptr
        __init__(self,  p) -> gr_clock_recovery_mm_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_clock_recovery_mm_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_clock_recovery_mm_ff_sptr
    __del__ = lambda self : None;
    def mu(self):
        """mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_mu(self)

    def omega(self):
        """omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_omega(self)

    def gain_mu(self):
        """gain_mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_gain_mu(self)

    def gain_omega(self):
        """gain_omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_gain_omega(self)

    def set_gain_mu(self, *args):
        """set_gain_mu(self, float gain_mu)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_set_gain_mu(self, *args)

    def set_gain_omega(self, *args):
        """set_gain_omega(self, float gain_omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_set_gain_omega(self, *args)

    def set_mu(self, *args):
        """set_mu(self, float omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_set_mu(self, *args)

    def set_omega(self, *args):
        """set_omega(self, float omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_set_omega(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_check_topology(self, *args)

gr_clock_recovery_mm_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_sptr_swigregister
gr_clock_recovery_mm_ff_sptr_swigregister(gr_clock_recovery_mm_ff_sptr)

def threshold_ff(*args):
  """
    threshold_ff(float lo, float hi, float initial_state = 0) -> gr_threshold_ff_sptr
    threshold_ff(float lo, float hi) -> gr_threshold_ff_sptr
    """
  return _gnuradio_swig_py_general.threshold_ff(*args)


def gr_clock_recovery_mm_ff_block(*args):
  """gr_clock_recovery_mm_ff_block(gr_clock_recovery_mm_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_clock_recovery_mm_ff_block(*args)
gr_clock_recovery_mm_ff_sptr.block = lambda self: gr_clock_recovery_mm_ff_block (self)
gr_clock_recovery_mm_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_clock_recovery_mm_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_clock_recovery_mm_cc_sptr
        __init__(self,  p) -> gr_clock_recovery_mm_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_clock_recovery_mm_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_clock_recovery_mm_cc_sptr
    __del__ = lambda self : None;
    def mu(self):
        """mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_mu(self)

    def omega(self):
        """omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_omega(self)

    def gain_mu(self):
        """gain_mu(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_gain_mu(self)

    def gain_omega(self):
        """gain_omega(self) -> float"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_gain_omega(self)

    def set_gain_mu(self, *args):
        """set_gain_mu(self, float gain_mu)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_gain_mu(self, *args)

    def set_gain_omega(self, *args):
        """set_gain_omega(self, float gain_omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_gain_omega(self, *args)

    def set_mu(self, *args):
        """set_mu(self, float omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_mu(self, *args)

    def set_omega(self, *args):
        """set_omega(self, float omega)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_omega(self, *args)

    def set_verbose(self, *args):
        """set_verbose(self, bool verbose)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_verbose(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_check_topology(self, *args)

gr_clock_recovery_mm_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_sptr_swigregister
gr_clock_recovery_mm_cc_sptr_swigregister(gr_clock_recovery_mm_cc_sptr)

def clock_recovery_mm_ff(*args):
  """
    clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu, 
        float omega_relative_limit = 0.001) -> gr_clock_recovery_mm_ff_sptr
    clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu) -> gr_clock_recovery_mm_ff_sptr
    """
  return _gnuradio_swig_py_general.clock_recovery_mm_ff(*args)


def gr_clock_recovery_mm_cc_block(*args):
  """gr_clock_recovery_mm_cc_block(gr_clock_recovery_mm_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_clock_recovery_mm_cc_block(*args)
gr_clock_recovery_mm_cc_sptr.block = lambda self: gr_clock_recovery_mm_cc_block (self)
gr_clock_recovery_mm_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def clock_recovery_mm_cc(*args):
  """
    clock_recovery_mm_cc(float omega, float gain_omega, float mu, float gain_mu, 
        float omega_relative_limit) -> gr_clock_recovery_mm_cc_sptr
    """
  return _gnuradio_swig_py_general.clock_recovery_mm_cc(*args)
class gr_dd_mpsk_sync_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_dd_mpsk_sync_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__(self) -> gr_dd_mpsk_sync_cc_sptr
        __init__(self,  p) -> gr_dd_mpsk_sync_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_dd_mpsk_sync_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_dd_mpsk_sync_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_check_topology(self, *args)

gr_dd_mpsk_sync_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_sptr_swigregister
gr_dd_mpsk_sync_cc_sptr_swigregister(gr_dd_mpsk_sync_cc_sptr)


def gr_dd_mpsk_sync_cc_block(*args):
  """gr_dd_mpsk_sync_cc_block(gr_dd_mpsk_sync_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_dd_mpsk_sync_cc_block(*args)
gr_dd_mpsk_sync_cc_sptr.block = lambda self: gr_dd_mpsk_sync_cc_block (self)
gr_dd_mpsk_sync_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def dd_mpsk_sync_cc(*args):
  """
    dd_mpsk_sync_cc(float alpha, float beta, float max_freq, float min_freq, 
        float ref_phase, float omega, float gain_omega, 
        float mu, float gain_mu) -> gr_dd_mpsk_sync_cc_sptr
    """
  return _gnuradio_swig_py_general.dd_mpsk_sync_cc(*args)
class gr_packet_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_packet_sink)> 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__(self) -> gr_packet_sink_sptr
        __init__(self,  p) -> gr_packet_sink_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_packet_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_packet_sink_sptr
    __del__ = lambda self : None;
    def carrier_sensed(self):
        """carrier_sensed(self) -> bool"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_carrier_sensed(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_packet_sink_sptr_check_topology(self, *args)

gr_packet_sink_sptr_swigregister = _gnuradio_swig_py_general.gr_packet_sink_sptr_swigregister
gr_packet_sink_sptr_swigregister(gr_packet_sink_sptr)


def gr_packet_sink_block(*args):
  """gr_packet_sink_block(gr_packet_sink_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_packet_sink_block(*args)
gr_packet_sink_sptr.block = lambda self: gr_packet_sink_block (self)
gr_packet_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_lms_dfe_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_lms_dfe_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__(self) -> gr_lms_dfe_cc_sptr
        __init__(self,  p) -> gr_lms_dfe_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_lms_dfe_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_lms_dfe_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_check_topology(self, *args)

gr_lms_dfe_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_lms_dfe_cc_sptr_swigregister
gr_lms_dfe_cc_sptr_swigregister(gr_lms_dfe_cc_sptr)

def packet_sink(*args):
  """
    packet_sink(__dummy_0__ sync_vector, gr_msg_queue_sptr target_queue, 
        int threshold = -1) -> gr_packet_sink_sptr
    packet_sink(__dummy_0__ sync_vector, gr_msg_queue_sptr target_queue) -> gr_packet_sink_sptr
    """
  return _gnuradio_swig_py_general.packet_sink(*args)


def gr_lms_dfe_cc_block(*args):
  """gr_lms_dfe_cc_block(gr_lms_dfe_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_lms_dfe_cc_block(*args)
gr_lms_dfe_cc_sptr.block = lambda self: gr_lms_dfe_cc_block (self)
gr_lms_dfe_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def lms_dfe_cc(*args):
  """
    lms_dfe_cc(float lambda_ff, float lambda_fb, unsigned int num_fftaps, 
        unsigned int num_fbtaps) -> gr_lms_dfe_cc_sptr
    """
  return _gnuradio_swig_py_general.lms_dfe_cc(*args)
class gr_lms_dfe_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_lms_dfe_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__(self) -> gr_lms_dfe_ff_sptr
        __init__(self,  p) -> gr_lms_dfe_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_lms_dfe_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_lms_dfe_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_check_topology(self, *args)

gr_lms_dfe_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_lms_dfe_ff_sptr_swigregister
gr_lms_dfe_ff_sptr_swigregister(gr_lms_dfe_ff_sptr)


def gr_lms_dfe_ff_block(*args):
  """gr_lms_dfe_ff_block(gr_lms_dfe_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_lms_dfe_ff_block(*args)
gr_lms_dfe_ff_sptr.block = lambda self: gr_lms_dfe_ff_block (self)
gr_lms_dfe_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def lms_dfe_ff(*args):
  """
    lms_dfe_ff(float lambda_ff, float lambda_fb, unsigned int num_fftaps, 
        unsigned int num_fbtaps) -> gr_lms_dfe_ff_sptr
    """
  return _gnuradio_swig_py_general.lms_dfe_ff(*args)
class gr_dpll_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_dpll_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__(self) -> gr_dpll_bb_sptr
        __init__(self,  p) -> gr_dpll_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_dpll_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_dpll_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_dpll_bb_sptr_check_topology(self, *args)

gr_dpll_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_dpll_bb_sptr_swigregister
gr_dpll_bb_sptr_swigregister(gr_dpll_bb_sptr)


def gr_dpll_bb_block(*args):
  """gr_dpll_bb_block(gr_dpll_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_dpll_bb_block(*args)
gr_dpll_bb_sptr.block = lambda self: gr_dpll_bb_block (self)
gr_dpll_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def dpll_bb(*args):
  """dpll_bb(float period, float gain) -> gr_dpll_bb_sptr"""
  return _gnuradio_swig_py_general.dpll_bb(*args)
class gr_pll_freqdet_cf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pll_freqdet_cf)> 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__(self) -> gr_pll_freqdet_cf_sptr
        __init__(self,  p) -> gr_pll_freqdet_cf_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pll_freqdet_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pll_freqdet_cf_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_check_topology(self, *args)

gr_pll_freqdet_cf_sptr_swigregister = _gnuradio_swig_py_general.gr_pll_freqdet_cf_sptr_swigregister
gr_pll_freqdet_cf_sptr_swigregister(gr_pll_freqdet_cf_sptr)


def gr_pll_freqdet_cf_block(*args):
  """gr_pll_freqdet_cf_block(gr_pll_freqdet_cf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pll_freqdet_cf_block(*args)
gr_pll_freqdet_cf_sptr.block = lambda self: gr_pll_freqdet_cf_block (self)
gr_pll_freqdet_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def pll_freqdet_cf(*args):
  """pll_freqdet_cf(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_freqdet_cf_sptr"""
  return _gnuradio_swig_py_general.pll_freqdet_cf(*args)
class gr_pll_refout_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pll_refout_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__(self) -> gr_pll_refout_cc_sptr
        __init__(self,  p) -> gr_pll_refout_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pll_refout_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pll_refout_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_check_topology(self, *args)

gr_pll_refout_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_pll_refout_cc_sptr_swigregister
gr_pll_refout_cc_sptr_swigregister(gr_pll_refout_cc_sptr)


def gr_pll_refout_cc_block(*args):
  """gr_pll_refout_cc_block(gr_pll_refout_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pll_refout_cc_block(*args)
gr_pll_refout_cc_sptr.block = lambda self: gr_pll_refout_cc_block (self)
gr_pll_refout_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def pll_refout_cc(*args):
  """pll_refout_cc(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_refout_cc_sptr"""
  return _gnuradio_swig_py_general.pll_refout_cc(*args)
class gr_pll_carriertracking_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pll_carriertracking_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__(self) -> gr_pll_carriertracking_cc_sptr
        __init__(self,  p) -> gr_pll_carriertracking_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pll_carriertracking_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pll_carriertracking_cc_sptr
    __del__ = lambda self : None;
    def lock_detector(self):
        """lock_detector(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_lock_detector(self)

    def squelch_enable(self, *args):
        """squelch_enable(self, bool arg0) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_squelch_enable(self, *args)

    def set_lock_threshold(self, *args):
        """set_lock_threshold(self, float arg0) -> float"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_set_lock_threshold(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_check_topology(self, *args)

gr_pll_carriertracking_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_pll_carriertracking_cc_sptr_swigregister
gr_pll_carriertracking_cc_sptr_swigregister(gr_pll_carriertracking_cc_sptr)


def gr_pll_carriertracking_cc_block(*args):
  """gr_pll_carriertracking_cc_block(gr_pll_carriertracking_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pll_carriertracking_cc_block(*args)
gr_pll_carriertracking_cc_sptr.block = lambda self: gr_pll_carriertracking_cc_block (self)
gr_pll_carriertracking_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def pll_carriertracking_cc(*args):
  """pll_carriertracking_cc(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_carriertracking_cc_sptr"""
  return _gnuradio_swig_py_general.pll_carriertracking_cc(*args)
class gr_pn_correlator_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pn_correlator_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__(self) -> gr_pn_correlator_cc_sptr
        __init__(self,  p) -> gr_pn_correlator_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pn_correlator_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pn_correlator_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_check_topology(self, *args)

gr_pn_correlator_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_pn_correlator_cc_sptr_swigregister
gr_pn_correlator_cc_sptr_swigregister(gr_pn_correlator_cc_sptr)


def gr_pn_correlator_cc_block(*args):
  """gr_pn_correlator_cc_block(gr_pn_correlator_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pn_correlator_cc_block(*args)
gr_pn_correlator_cc_sptr.block = lambda self: gr_pn_correlator_cc_block (self)
gr_pn_correlator_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_probe_avg_mag_sqrd_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_probe_avg_mag_sqrd_c)> 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__(self) -> gr_probe_avg_mag_sqrd_c_sptr
        __init__(self,  p) -> gr_probe_avg_mag_sqrd_c_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_probe_avg_mag_sqrd_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_probe_avg_mag_sqrd_c_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_unmuted(self)

    def level(self):
        """level(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_level(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_set_alpha(self, *args)

    def set_threshold(self, *args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_set_threshold(self, *args)

    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_threshold(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_check_topology(self, *args)

gr_probe_avg_mag_sqrd_c_sptr_swigregister = _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_sptr_swigregister
gr_probe_avg_mag_sqrd_c_sptr_swigregister(gr_probe_avg_mag_sqrd_c_sptr)

def pn_correlator_cc(*args):
  """
    pn_correlator_cc(int degree, int mask = 0, int seed = 1) -> gr_pn_correlator_cc_sptr
    pn_correlator_cc(int degree, int mask = 0) -> gr_pn_correlator_cc_sptr
    pn_correlator_cc(int degree) -> gr_pn_correlator_cc_sptr
    """
  return _gnuradio_swig_py_general.pn_correlator_cc(*args)


def gr_probe_avg_mag_sqrd_c_block(*args):
  """gr_probe_avg_mag_sqrd_c_block(gr_probe_avg_mag_sqrd_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_c_block(*args)
gr_probe_avg_mag_sqrd_c_sptr.block = lambda self: gr_probe_avg_mag_sqrd_c_block (self)
gr_probe_avg_mag_sqrd_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_probe_avg_mag_sqrd_cf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_probe_avg_mag_sqrd_cf)> 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__(self) -> gr_probe_avg_mag_sqrd_cf_sptr
        __init__(self,  p) -> gr_probe_avg_mag_sqrd_cf_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_probe_avg_mag_sqrd_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_probe_avg_mag_sqrd_cf_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_unmuted(self)

    def level(self):
        """level(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_level(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_set_alpha(self, *args)

    def set_threshold(self, *args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_set_threshold(self, *args)

    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_threshold(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_check_topology(self, *args)

gr_probe_avg_mag_sqrd_cf_sptr_swigregister = _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_sptr_swigregister
gr_probe_avg_mag_sqrd_cf_sptr_swigregister(gr_probe_avg_mag_sqrd_cf_sptr)

def probe_avg_mag_sqrd_c(*args):
  """
    probe_avg_mag_sqrd_c(double threshold_db, double alpha = 0.0001) -> gr_probe_avg_mag_sqrd_c_sptr
    probe_avg_mag_sqrd_c(double threshold_db) -> gr_probe_avg_mag_sqrd_c_sptr
    """
  return _gnuradio_swig_py_general.probe_avg_mag_sqrd_c(*args)


def gr_probe_avg_mag_sqrd_cf_block(*args):
  """gr_probe_avg_mag_sqrd_cf_block(gr_probe_avg_mag_sqrd_cf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_cf_block(*args)
gr_probe_avg_mag_sqrd_cf_sptr.block = lambda self: gr_probe_avg_mag_sqrd_cf_block (self)
gr_probe_avg_mag_sqrd_cf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_probe_avg_mag_sqrd_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_probe_avg_mag_sqrd_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__(self) -> gr_probe_avg_mag_sqrd_f_sptr
        __init__(self,  p) -> gr_probe_avg_mag_sqrd_f_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_probe_avg_mag_sqrd_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_probe_avg_mag_sqrd_f_sptr
    __del__ = lambda self : None;
    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_unmuted(self)

    def level(self):
        """level(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_level(self)

    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_threshold(self)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_set_alpha(self, *args)

    def set_threshold(self, *args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_set_threshold(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_check_topology(self, *args)

gr_probe_avg_mag_sqrd_f_sptr_swigregister = _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_sptr_swigregister
gr_probe_avg_mag_sqrd_f_sptr_swigregister(gr_probe_avg_mag_sqrd_f_sptr)

def probe_avg_mag_sqrd_cf(*args):
  """
    probe_avg_mag_sqrd_cf(double threshold_db, double alpha = 0.0001) -> gr_probe_avg_mag_sqrd_cf_sptr
    probe_avg_mag_sqrd_cf(double threshold_db) -> gr_probe_avg_mag_sqrd_cf_sptr
    """
  return _gnuradio_swig_py_general.probe_avg_mag_sqrd_cf(*args)


def gr_probe_avg_mag_sqrd_f_block(*args):
  """gr_probe_avg_mag_sqrd_f_block(gr_probe_avg_mag_sqrd_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_probe_avg_mag_sqrd_f_block(*args)
gr_probe_avg_mag_sqrd_f_sptr.block = lambda self: gr_probe_avg_mag_sqrd_f_block (self)
gr_probe_avg_mag_sqrd_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_probe_signal_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_probe_signal_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__(self) -> gr_probe_signal_f_sptr
        __init__(self,  p) -> gr_probe_signal_f_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_probe_signal_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_probe_signal_f_sptr
    __del__ = lambda self : None;
    def level(self):
        """level(self) -> float"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_level(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_probe_signal_f_sptr_check_topology(self, *args)

gr_probe_signal_f_sptr_swigregister = _gnuradio_swig_py_general.gr_probe_signal_f_sptr_swigregister
gr_probe_signal_f_sptr_swigregister(gr_probe_signal_f_sptr)

def probe_avg_mag_sqrd_f(*args):
  """
    probe_avg_mag_sqrd_f(double threshold_db, double alpha = 0.0001) -> gr_probe_avg_mag_sqrd_f_sptr
    probe_avg_mag_sqrd_f(double threshold_db) -> gr_probe_avg_mag_sqrd_f_sptr
    """
  return _gnuradio_swig_py_general.probe_avg_mag_sqrd_f(*args)


def gr_probe_signal_f_block(*args):
  """gr_probe_signal_f_block(gr_probe_signal_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_probe_signal_f_block(*args)
gr_probe_signal_f_sptr.block = lambda self: gr_probe_signal_f_block (self)
gr_probe_signal_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def probe_signal_f():
  """probe_signal_f() -> gr_probe_signal_f_sptr"""
  return _gnuradio_swig_py_general.probe_signal_f()
class gr_regenerate_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_regenerate_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__(self) -> gr_regenerate_bb_sptr
        __init__(self,  p) -> gr_regenerate_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_regenerate_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_regenerate_bb_sptr
    __del__ = lambda self : None;
    def set_max_regen(self, *args):
        """set_max_regen(self, unsigned int regen)"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_set_max_regen(self, *args)

    def set_period(self, *args):
        """set_period(self, int period)"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_set_period(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_regenerate_bb_sptr_check_topology(self, *args)

gr_regenerate_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_regenerate_bb_sptr_swigregister
gr_regenerate_bb_sptr_swigregister(gr_regenerate_bb_sptr)


def gr_regenerate_bb_block(*args):
  """gr_regenerate_bb_block(gr_regenerate_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_regenerate_bb_block(*args)
gr_regenerate_bb_sptr.block = lambda self: gr_regenerate_bb_block (self)
gr_regenerate_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_costas_loop_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_costas_loop_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__(self) -> gr_costas_loop_cc_sptr
        __init__(self,  p) -> gr_costas_loop_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_costas_loop_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_costas_loop_cc_sptr
    __del__ = lambda self : None;
    def set_alpha(self, *args):
        """set_alpha(self, float alpha)"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_set_alpha(self, *args)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_alpha(self)

    def set_beta(self, *args):
        """set_beta(self, float beta)"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_set_beta(self, *args)

    def beta(self):
        """beta(self) -> float"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_beta(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_check_topology(self, *args)

gr_costas_loop_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_costas_loop_cc_sptr_swigregister
gr_costas_loop_cc_sptr_swigregister(gr_costas_loop_cc_sptr)

def regenerate_bb(*args):
  """
    regenerate_bb(int period, unsigned int max_regen = 500) -> gr_regenerate_bb_sptr
    regenerate_bb(int period) -> gr_regenerate_bb_sptr
    """
  return _gnuradio_swig_py_general.regenerate_bb(*args)


def gr_costas_loop_cc_block(*args):
  """gr_costas_loop_cc_block(gr_costas_loop_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_costas_loop_cc_block(*args)
gr_costas_loop_cc_sptr.block = lambda self: gr_costas_loop_cc_block (self)
gr_costas_loop_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def costas_loop_cc(*args):
  """
    costas_loop_cc(float alpha, float beta, float max_freq, float min_freq, 
        int order) -> gr_costas_loop_cc_sptr
    """
  return _gnuradio_swig_py_general.costas_loop_cc(*args)
class gr_pa_2x2_phase_combiner_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pa_2x2_phase_combiner)> 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__(self) -> gr_pa_2x2_phase_combiner_sptr
        __init__(self,  p) -> gr_pa_2x2_phase_combiner_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pa_2x2_phase_combiner_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pa_2x2_phase_combiner_sptr
    __del__ = lambda self : None;
    def theta(self):
        """theta(self) -> float"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_theta(self)

    def set_theta(self, *args):
        """set_theta(self, float theta)"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_set_theta(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_check_topology(self, *args)

gr_pa_2x2_phase_combiner_sptr_swigregister = _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_sptr_swigregister
gr_pa_2x2_phase_combiner_sptr_swigregister(gr_pa_2x2_phase_combiner_sptr)


def gr_pa_2x2_phase_combiner_block(*args):
  """gr_pa_2x2_phase_combiner_block(gr_pa_2x2_phase_combiner_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pa_2x2_phase_combiner_block(*args)
gr_pa_2x2_phase_combiner_sptr.block = lambda self: gr_pa_2x2_phase_combiner_block (self)
gr_pa_2x2_phase_combiner_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def pa_2x2_phase_combiner():
  """pa_2x2_phase_combiner() -> gr_pa_2x2_phase_combiner_sptr"""
  return _gnuradio_swig_py_general.pa_2x2_phase_combiner()
class gr_kludge_copy_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_kludge_copy)> 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__(self) -> gr_kludge_copy_sptr
        __init__(self,  p) -> gr_kludge_copy_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_kludge_copy_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_kludge_copy_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_kludge_copy_sptr_check_topology(self, *args)

gr_kludge_copy_sptr_swigregister = _gnuradio_swig_py_general.gr_kludge_copy_sptr_swigregister
gr_kludge_copy_sptr_swigregister(gr_kludge_copy_sptr)


def gr_kludge_copy_block(*args):
  """gr_kludge_copy_block(gr_kludge_copy_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_kludge_copy_block(*args)
gr_kludge_copy_sptr.block = lambda self: gr_kludge_copy_block (self)
gr_kludge_copy_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def kludge_copy(*args):
  """kludge_copy(size_t itemsize) -> gr_kludge_copy_sptr"""
  return _gnuradio_swig_py_general.kludge_copy(*args)
class gr_prefs(object):
    """Proxy of C++ gr_prefs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def singleton():
        """singleton() -> gr_prefs"""
        return _gnuradio_swig_py_general.gr_prefs_singleton()

    singleton = staticmethod(singleton)
    def set_singleton(*args):
        """set_singleton(gr_prefs p)"""
        return _gnuradio_swig_py_general.gr_prefs_set_singleton(*args)

    set_singleton = staticmethod(set_singleton)
    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_prefs
    __del__ = lambda self : None;
    def has_section(self, *args):
        """has_section(self, string section) -> bool"""
        return _gnuradio_swig_py_general.gr_prefs_has_section(self, *args)

    def has_option(self, *args):
        """has_option(self, string section, string option) -> bool"""
        return _gnuradio_swig_py_general.gr_prefs_has_option(self, *args)

    def get_string(self, *args):
        """get_string(self, string section, string option, string default_val) -> string"""
        return _gnuradio_swig_py_general.gr_prefs_get_string(self, *args)

    def get_bool(self, *args):
        """get_bool(self, string section, string option, bool default_val) -> bool"""
        return _gnuradio_swig_py_general.gr_prefs_get_bool(self, *args)

    def get_long(self, *args):
        """get_long(self, string section, string option, long default_val) -> long"""
        return _gnuradio_swig_py_general.gr_prefs_get_long(self, *args)

    def get_double(self, *args):
        """get_double(self, string section, string option, double default_val) -> double"""
        return _gnuradio_swig_py_general.gr_prefs_get_double(self, *args)

    def __init__(self): 
        """__init__(self) -> gr_prefs"""
        if self.__class__ == gr_prefs:
            _self = None
        else:
            _self = self
        this = _gnuradio_swig_py_general.new_gr_prefs(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_py_general.disown_gr_prefs(self)
        return weakref_proxy(self)
gr_prefs_swigregister = _gnuradio_swig_py_general.gr_prefs_swigregister
gr_prefs_swigregister(gr_prefs)

def gr_prefs_singleton():
  """gr_prefs_singleton() -> gr_prefs"""
  return _gnuradio_swig_py_general.gr_prefs_singleton()

def gr_prefs_set_singleton(*args):
  """gr_prefs_set_singleton(gr_prefs p)"""
  return _gnuradio_swig_py_general.gr_prefs_set_singleton(*args)


def prefix():
  """prefix() -> string"""
  return _gnuradio_swig_py_general.prefix()
CONSUME_NOUTPUT_ITEMS = _gnuradio_swig_py_general.CONSUME_NOUTPUT_ITEMS
CONSUME_NOUTPUT_ITEMS_LIMIT_MAX = _gnuradio_swig_py_general.CONSUME_NOUTPUT_ITEMS_LIMIT_MAX
CONSUME_NOUTPUT_ITEMS_LIMIT_MIN = _gnuradio_swig_py_general.CONSUME_NOUTPUT_ITEMS_LIMIT_MIN
CONSUME_ALL_AVAILABLE = _gnuradio_swig_py_general.CONSUME_ALL_AVAILABLE
CONSUME_ALL_AVAILABLE_LIMIT_MAX = _gnuradio_swig_py_general.CONSUME_ALL_AVAILABLE_LIMIT_MAX
CONSUME_ZERO = _gnuradio_swig_py_general.CONSUME_ZERO
CONSUME_ONE = _gnuradio_swig_py_general.CONSUME_ONE
CONSUME_MINUS_ONE = _gnuradio_swig_py_general.CONSUME_MINUS_ONE
PRODUCE_NOUTPUT_ITEMS = _gnuradio_swig_py_general.PRODUCE_NOUTPUT_ITEMS
PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX = _gnuradio_swig_py_general.PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX
PRODUCE_ZERO = _gnuradio_swig_py_general.PRODUCE_ZERO
PRODUCE_ONE = _gnuradio_swig_py_general.PRODUCE_ONE
PRODUCE_MINUS_ONE = _gnuradio_swig_py_general.PRODUCE_MINUS_ONE
class gr_test_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_test)> 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__(self) -> gr_test_sptr
        __init__(self,  p) -> gr_test_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_test_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_test_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_test_sptr
    __del__ = lambda self : None;
    def forecast(self, *args):
        """forecast(self, int noutput_items, gr_vector_int ninput_items_required)"""
        return _gnuradio_swig_py_general.gr_test_sptr_forecast(self, *args)

    def set_check_topology(self, *args):
        """set_check_topology(self, bool check_topology)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_check_topology(self, *args)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_test_sptr_check_topology(self, *args)

    def fixed_rate_ninput_to_noutput(self, *args):
        """fixed_rate_ninput_to_noutput(self, int ninput) -> int"""
        return _gnuradio_swig_py_general.gr_test_sptr_fixed_rate_ninput_to_noutput(self, *args)

    def fixed_rate_noutput_to_ninput(self, *args):
        """fixed_rate_noutput_to_ninput(self, int noutput) -> int"""
        return _gnuradio_swig_py_general.gr_test_sptr_fixed_rate_noutput_to_ninput(self, *args)

    def set_fixed_rate_public(self, *args):
        """set_fixed_rate_public(self, bool fixed_rate)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_fixed_rate_public(self, *args)

    def set_consume_type(self, *args):
        """set_consume_type(self, gr_consume_type_t cons_type)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_consume_type(self, *args)

    def set_consume_limit(self, *args):
        """set_consume_limit(self, unsigned int limit)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_consume_limit(self, *args)

    def set_produce_type(self, *args):
        """set_produce_type(self, gr_produce_type_t prod_type)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_produce_type(self, *args)

    def set_produce_limit(self, *args):
        """set_produce_limit(self, unsigned int limit)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_produce_limit(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_test_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_test_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_test_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_test_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_test_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_test_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_test_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_test_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_test_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_test_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_test_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_test_sptr_basic_block(self)

gr_test_sptr_swigregister = _gnuradio_swig_py_general.gr_test_sptr_swigregister
gr_test_sptr_swigregister(gr_test_sptr)


def gr_test_block(*args):
  """gr_test_block(gr_test_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_test_block(*args)
gr_test_sptr.block = lambda self: gr_test_block (self)
gr_test_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_unpack_k_bits_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_unpack_k_bits_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__(self) -> gr_unpack_k_bits_bb_sptr
        __init__(self,  p) -> gr_unpack_k_bits_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_unpack_k_bits_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_unpack_k_bits_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_check_topology(self, *args)

gr_unpack_k_bits_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_unpack_k_bits_bb_sptr_swigregister
gr_unpack_k_bits_bb_sptr_swigregister(gr_unpack_k_bits_bb_sptr)

def test(*args):
  """
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1, unsigned int output_multiple = 1, 
        double relative_rate = 1.0, 
        bool fixed_rate = True, gr_consume_type_t cons_type = CONSUME_NOUTPUT_ITEMS, 
        gr_produce_type_t prod_type = PRODUCE_NOUTPUT_ITEMS) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1, unsigned int output_multiple = 1, 
        double relative_rate = 1.0, 
        bool fixed_rate = True, gr_consume_type_t cons_type = CONSUME_NOUTPUT_ITEMS) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1, unsigned int output_multiple = 1, 
        double relative_rate = 1.0, 
        bool fixed_rate = True) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1, unsigned int output_multiple = 1, 
        double relative_rate = 1.0) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1, unsigned int output_multiple = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1, 
        unsigned int history = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1, 
        unsigned int sizeof_output_item = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1, int max_outputs = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1, 
        int min_outputs = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1, unsigned int sizeof_input_item = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1, 
        int max_inputs = 1) -> gr_test_sptr
    test(string name = std::string("gr_test"), int min_inputs = 1) -> gr_test_sptr
    test(string name = std::string("gr_test")) -> gr_test_sptr
    test() -> gr_test_sptr
    """
  return _gnuradio_swig_py_general.test(*args)


def gr_unpack_k_bits_bb_block(*args):
  """gr_unpack_k_bits_bb_block(gr_unpack_k_bits_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_unpack_k_bits_bb_block(*args)
gr_unpack_k_bits_bb_sptr.block = lambda self: gr_unpack_k_bits_bb_block (self)
gr_unpack_k_bits_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def unpack_k_bits_bb(*args):
  """unpack_k_bits_bb(int k) -> gr_unpack_k_bits_bb_sptr"""
  return _gnuradio_swig_py_general.unpack_k_bits_bb(*args)
class gr_correlate_access_code_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_correlate_access_code_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__(self) -> gr_correlate_access_code_bb_sptr
        __init__(self,  p) -> gr_correlate_access_code_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_correlate_access_code_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_correlate_access_code_bb_sptr
    __del__ = lambda self : None;
    def set_access_code(self, *args):
        """set_access_code(self, string access_code) -> bool"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_set_access_code(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_check_topology(self, *args)

gr_correlate_access_code_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_correlate_access_code_bb_sptr_swigregister
gr_correlate_access_code_bb_sptr_swigregister(gr_correlate_access_code_bb_sptr)


def gr_correlate_access_code_bb_block(*args):
  """gr_correlate_access_code_bb_block(gr_correlate_access_code_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_correlate_access_code_bb_block(*args)
gr_correlate_access_code_bb_sptr.block = lambda self: gr_correlate_access_code_bb_block (self)
gr_correlate_access_code_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def correlate_access_code_bb(*args):
  """correlate_access_code_bb(string access_code, int threshold) -> gr_correlate_access_code_bb_sptr"""
  return _gnuradio_swig_py_general.correlate_access_code_bb(*args)
class gr_diff_phasor_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_diff_phasor_cc_sptr
        __init__(self,  p) -> gr_diff_phasor_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_diff_phasor_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_diff_phasor_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_check_topology(self, *args)

gr_diff_phasor_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_diff_phasor_cc_sptr_swigregister
gr_diff_phasor_cc_sptr_swigregister(gr_diff_phasor_cc_sptr)


def gr_diff_phasor_cc_block(*args):
  """gr_diff_phasor_cc_block(gr_diff_phasor_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_diff_phasor_cc_block(*args)
gr_diff_phasor_cc_sptr.block = lambda self: gr_diff_phasor_cc_block (self)
gr_diff_phasor_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def diff_phasor_cc():
  """diff_phasor_cc() -> gr_diff_phasor_cc_sptr"""
  return _gnuradio_swig_py_general.diff_phasor_cc()
class gr_constellation_decoder_cb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_constellation_decoder_cb)> 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__(self) -> gr_constellation_decoder_cb_sptr
        __init__(self,  p) -> gr_constellation_decoder_cb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_constellation_decoder_cb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_constellation_decoder_cb_sptr
    __del__ = lambda self : None;
    def set_constellation(self, *args):
        """
        set_constellation(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> sym_position, 
            __dummy_0__ sym_value_out) -> int
        """
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_set_constellation(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_check_topology(self, *args)

gr_constellation_decoder_cb_sptr_swigregister = _gnuradio_swig_py_general.gr_constellation_decoder_cb_sptr_swigregister
gr_constellation_decoder_cb_sptr_swigregister(gr_constellation_decoder_cb_sptr)


def gr_constellation_decoder_cb_block(*args):
  """gr_constellation_decoder_cb_block(gr_constellation_decoder_cb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_constellation_decoder_cb_block(*args)
gr_constellation_decoder_cb_sptr.block = lambda self: gr_constellation_decoder_cb_block (self)
gr_constellation_decoder_cb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def constellation_decoder_cb(*args):
  """
    constellation_decoder_cb(std::vector<(gr_complex,std::allocator<(gr_complex)>)> sym_position, 
        __dummy_0__ sym_value_out) -> gr_constellation_decoder_cb_sptr
    """
  return _gnuradio_swig_py_general.constellation_decoder_cb(*args)
class gr_binary_slicer_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_binary_slicer_fb)> 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__(self) -> gr_binary_slicer_fb_sptr
        __init__(self,  p) -> gr_binary_slicer_fb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_binary_slicer_fb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_binary_slicer_fb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_check_topology(self, *args)

gr_binary_slicer_fb_sptr_swigregister = _gnuradio_swig_py_general.gr_binary_slicer_fb_sptr_swigregister
gr_binary_slicer_fb_sptr_swigregister(gr_binary_slicer_fb_sptr)


def gr_binary_slicer_fb_block(*args):
  """gr_binary_slicer_fb_block(gr_binary_slicer_fb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_binary_slicer_fb_block(*args)
gr_binary_slicer_fb_sptr.block = lambda self: gr_binary_slicer_fb_block (self)
gr_binary_slicer_fb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def binary_slicer_fb():
  """binary_slicer_fb() -> gr_binary_slicer_fb_sptr"""
  return _gnuradio_swig_py_general.binary_slicer_fb()
class gr_diff_encoder_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_diff_encoder_bb_sptr
        __init__(self,  p) -> gr_diff_encoder_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_diff_encoder_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_diff_encoder_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_check_topology(self, *args)

gr_diff_encoder_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_diff_encoder_bb_sptr_swigregister
gr_diff_encoder_bb_sptr_swigregister(gr_diff_encoder_bb_sptr)


def gr_diff_encoder_bb_block(*args):
  """gr_diff_encoder_bb_block(gr_diff_encoder_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_diff_encoder_bb_block(*args)
gr_diff_encoder_bb_sptr.block = lambda self: gr_diff_encoder_bb_block (self)
gr_diff_encoder_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def diff_encoder_bb(*args):
  """diff_encoder_bb(unsigned int modulus) -> gr_diff_encoder_bb_sptr"""
  return _gnuradio_swig_py_general.diff_encoder_bb(*args)
class gr_diff_decoder_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_diff_decoder_bb_sptr
        __init__(self,  p) -> gr_diff_decoder_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_diff_decoder_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_diff_decoder_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_check_topology(self, *args)

gr_diff_decoder_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_diff_decoder_bb_sptr_swigregister
gr_diff_decoder_bb_sptr_swigregister(gr_diff_decoder_bb_sptr)


def gr_diff_decoder_bb_block(*args):
  """gr_diff_decoder_bb_block(gr_diff_decoder_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_diff_decoder_bb_block(*args)
gr_diff_decoder_bb_sptr.block = lambda self: gr_diff_decoder_bb_block (self)
gr_diff_decoder_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def diff_decoder_bb(*args):
  """diff_decoder_bb(unsigned int modulus) -> gr_diff_decoder_bb_sptr"""
  return _gnuradio_swig_py_general.diff_decoder_bb(*args)
class gr_framer_sink_1_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_framer_sink_1_sptr
        __init__(self,  p) -> gr_framer_sink_1_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_framer_sink_1_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_framer_sink_1_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_framer_sink_1_sptr_check_topology(self, *args)

gr_framer_sink_1_sptr_swigregister = _gnuradio_swig_py_general.gr_framer_sink_1_sptr_swigregister
gr_framer_sink_1_sptr_swigregister(gr_framer_sink_1_sptr)


def gr_framer_sink_1_block(*args):
  """gr_framer_sink_1_block(gr_framer_sink_1_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_framer_sink_1_block(*args)
gr_framer_sink_1_sptr.block = lambda self: gr_framer_sink_1_block (self)
gr_framer_sink_1_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def framer_sink_1(*args):
  """framer_sink_1(gr_msg_queue_sptr target_queue) -> gr_framer_sink_1_sptr"""
  return _gnuradio_swig_py_general.framer_sink_1(*args)
class gr_map_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_map_bb_sptr
        __init__(self,  p) -> gr_map_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_map_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_map_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_map_bb_sptr_check_topology(self, *args)

gr_map_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_map_bb_sptr_swigregister
gr_map_bb_sptr_swigregister(gr_map_bb_sptr)


def gr_map_bb_block(*args):
  """gr_map_bb_block(gr_map_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_map_bb_block(*args)
gr_map_bb_sptr.block = lambda self: gr_map_bb_block (self)
gr_map_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def map_bb(*args):
  """map_bb(__dummy_3__ map) -> gr_map_bb_sptr"""
  return _gnuradio_swig_py_general.map_bb(*args)
class feval_dd(object):
    """Proxy of C++ gr_py_feval_dd class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def calleval(self, *args):
        """calleval(self, double x) -> double"""
        return _gnuradio_swig_py_general.feval_dd_calleval(self, *args)

    def __init__(self): 
        """__init__(self) -> feval_dd"""
        if self.__class__ == feval_dd:
            _self = None
        else:
            _self = self
        this = _gnuradio_swig_py_general.new_feval_dd(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_feval_dd
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_py_general.disown_feval_dd(self)
        return weakref_proxy(self)
    def eval(self, *args):
        """eval(self, double x) -> double"""
        return _gnuradio_swig_py_general.feval_dd_eval(self, *args)

feval_dd_swigregister = _gnuradio_swig_py_general.feval_dd_swigregister
feval_dd_swigregister(feval_dd)

class feval_cc(object):
    """Proxy of C++ gr_py_feval_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 calleval(self, *args):
        """calleval(self, gr_complex x) -> gr_complex"""
        return _gnuradio_swig_py_general.feval_cc_calleval(self, *args)

    def __init__(self): 
        """__init__(self) -> feval_cc"""
        if self.__class__ == feval_cc:
            _self = None
        else:
            _self = self
        this = _gnuradio_swig_py_general.new_feval_cc(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_feval_cc
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_py_general.disown_feval_cc(self)
        return weakref_proxy(self)
    def eval(self, *args):
        """eval(self, gr_complex x) -> gr_complex"""
        return _gnuradio_swig_py_general.feval_cc_eval(self, *args)

feval_cc_swigregister = _gnuradio_swig_py_general.feval_cc_swigregister
feval_cc_swigregister(feval_cc)

class feval_ll(object):
    """Proxy of C++ gr_py_feval_ll class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def calleval(self, *args):
        """calleval(self, long x) -> long"""
        return _gnuradio_swig_py_general.feval_ll_calleval(self, *args)

    def __init__(self): 
        """__init__(self) -> feval_ll"""
        if self.__class__ == feval_ll:
            _self = None
        else:
            _self = self
        this = _gnuradio_swig_py_general.new_feval_ll(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_feval_ll
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_py_general.disown_feval_ll(self)
        return weakref_proxy(self)
    def eval(self, *args):
        """eval(self, long x) -> long"""
        return _gnuradio_swig_py_general.feval_ll_eval(self, *args)

feval_ll_swigregister = _gnuradio_swig_py_general.feval_ll_swigregister
feval_ll_swigregister(feval_ll)

class feval(object):
    """Proxy of C++ gr_py_feval class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def calleval(self):
        """calleval(self)"""
        return _gnuradio_swig_py_general.feval_calleval(self)

    def __init__(self): 
        """__init__(self) -> feval"""
        if self.__class__ == feval:
            _self = None
        else:
            _self = self
        this = _gnuradio_swig_py_general.new_feval(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_general.delete_feval
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_py_general.disown_feval(self)
        return weakref_proxy(self)
    def eval(self):
        """eval(self)"""
        return _gnuradio_swig_py_general.feval_eval(self)

feval_swigregister = _gnuradio_swig_py_general.feval_swigregister
feval_swigregister(feval)


def feval_dd_example(*args):
  """feval_dd_example( f, double x) -> double"""
  return _gnuradio_swig_py_general.feval_dd_example(*args)

def feval_cc_example(*args):
  """feval_cc_example( f, gr_complex x) -> gr_complex"""
  return _gnuradio_swig_py_general.feval_cc_example(*args)

def feval_ll_example(*args):
  """feval_ll_example( f, long x) -> long"""
  return _gnuradio_swig_py_general.feval_ll_example(*args)

def feval_example(*args):
  """feval_example( f)"""
  return _gnuradio_swig_py_general.feval_example(*args)
class gr_pwr_squelch_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pwr_squelch_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__(self) -> gr_pwr_squelch_cc_sptr
        __init__(self,  p) -> gr_pwr_squelch_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pwr_squelch_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pwr_squelch_cc_sptr
    __del__ = lambda self : None;
    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_threshold(self)

    def set_threshold(self, *args):
        """set_threshold(self, double db)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_set_threshold(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_set_alpha(self, *args)

    def ramp(self):
        """ramp(self) -> int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_ramp(self)

    def set_ramp(self, *args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_set_ramp(self, *args)

    def gate(self):
        """gate(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_gate(self)

    def set_gate(self, *args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_set_gate(self, *args)

    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_unmuted(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_check_topology(self, *args)

gr_pwr_squelch_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_pwr_squelch_cc_sptr_swigregister
gr_pwr_squelch_cc_sptr_swigregister(gr_pwr_squelch_cc_sptr)


def gr_pwr_squelch_cc_block(*args):
  """gr_pwr_squelch_cc_block(gr_pwr_squelch_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pwr_squelch_cc_block(*args)
gr_pwr_squelch_cc_sptr.block = lambda self: gr_pwr_squelch_cc_block (self)
gr_pwr_squelch_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_squelch_base_cc(object):
    """Proxy of C++ gr_squelch_base_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 ramp(self):
        """ramp(self) -> int"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_ramp(self)

    def set_ramp(self, *args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_set_ramp(self, *args)

    def gate(self):
        """gate(self) -> bool"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_gate(self)

    def set_gate(self, *args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_set_gate(self, *args)

    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_unmuted(self)

    def squelch_range(self):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_py_general.gr_squelch_base_cc_squelch_range(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_squelch_base_cc
    __del__ = lambda self : None;
gr_squelch_base_cc_swigregister = _gnuradio_swig_py_general.gr_squelch_base_cc_swigregister
gr_squelch_base_cc_swigregister(gr_squelch_base_cc)

class gr_pwr_squelch_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_pwr_squelch_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__(self) -> gr_pwr_squelch_ff_sptr
        __init__(self,  p) -> gr_pwr_squelch_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_pwr_squelch_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_pwr_squelch_ff_sptr
    __del__ = lambda self : None;
    def threshold(self):
        """threshold(self) -> double"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_threshold(self)

    def set_threshold(self, *args):
        """set_threshold(self, double db)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_set_threshold(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_set_alpha(self, *args)

    def ramp(self):
        """ramp(self) -> int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_ramp(self)

    def set_ramp(self, *args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_set_ramp(self, *args)

    def gate(self):
        """gate(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_gate(self)

    def set_gate(self, *args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_set_gate(self, *args)

    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_unmuted(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_check_topology(self, *args)

gr_pwr_squelch_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_pwr_squelch_ff_sptr_swigregister
gr_pwr_squelch_ff_sptr_swigregister(gr_pwr_squelch_ff_sptr)

def pwr_squelch_cc(*args):
  """
    pwr_squelch_cc(double db, double alpha = 0.0001, int ramp = 0, bool gate = False) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db, double alpha = 0.0001, int ramp = 0) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db, double alpha = 0.0001) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db) -> gr_pwr_squelch_cc_sptr
    """
  return _gnuradio_swig_py_general.pwr_squelch_cc(*args)


def gr_pwr_squelch_ff_block(*args):
  """gr_pwr_squelch_ff_block(gr_pwr_squelch_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_pwr_squelch_ff_block(*args)
gr_pwr_squelch_ff_sptr.block = lambda self: gr_pwr_squelch_ff_block (self)
gr_pwr_squelch_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_squelch_base_ff(object):
    """Proxy of C++ gr_squelch_base_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")
    __repr__ = _swig_repr
    def ramp(self):
        """ramp(self) -> int"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_ramp(self)

    def set_ramp(self, *args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_set_ramp(self, *args)

    def gate(self):
        """gate(self) -> bool"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_gate(self)

    def set_gate(self, *args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_set_gate(self, *args)

    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_unmuted(self)

    def squelch_range(self):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_py_general.gr_squelch_base_ff_squelch_range(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_squelch_base_ff
    __del__ = lambda self : None;
gr_squelch_base_ff_swigregister = _gnuradio_swig_py_general.gr_squelch_base_ff_swigregister
gr_squelch_base_ff_swigregister(gr_squelch_base_ff)

class gr_ctcss_squelch_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_ctcss_squelch_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__(self) -> gr_ctcss_squelch_ff_sptr
        __init__(self,  p) -> gr_ctcss_squelch_ff_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_ctcss_squelch_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_ctcss_squelch_ff_sptr
    __del__ = lambda self : None;
    def level(self):
        """level(self) -> float"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_level(self)

    def set_level(self, *args):
        """set_level(self, float level)"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_set_level(self, *args)

    def len(self):
        """len(self) -> int"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_len(self)

    def ramp(self):
        """ramp(self) -> int"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_ramp(self)

    def set_ramp(self, *args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_set_ramp(self, *args)

    def gate(self):
        """gate(self) -> bool"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_gate(self)

    def set_gate(self, *args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_set_gate(self, *args)

    def unmuted(self):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_unmuted(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_check_topology(self, *args)

gr_ctcss_squelch_ff_sptr_swigregister = _gnuradio_swig_py_general.gr_ctcss_squelch_ff_sptr_swigregister
gr_ctcss_squelch_ff_sptr_swigregister(gr_ctcss_squelch_ff_sptr)

def pwr_squelch_ff(*args):
  """
    pwr_squelch_ff(double db, double alpha = 0.0001, int ramp = 0, bool gate = False) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db, double alpha = 0.0001, int ramp = 0) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db, double alpha = 0.0001) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db) -> gr_pwr_squelch_ff_sptr
    """
  return _gnuradio_swig_py_general.pwr_squelch_ff(*args)


def gr_ctcss_squelch_ff_block(*args):
  """gr_ctcss_squelch_ff_block(gr_ctcss_squelch_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_ctcss_squelch_ff_block(*args)
gr_ctcss_squelch_ff_sptr.block = lambda self: gr_ctcss_squelch_ff_block (self)
gr_ctcss_squelch_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_feedforward_agc_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_feedforward_agc_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__(self) -> gr_feedforward_agc_cc_sptr
        __init__(self,  p) -> gr_feedforward_agc_cc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_feedforward_agc_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_feedforward_agc_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_check_topology(self, *args)

gr_feedforward_agc_cc_sptr_swigregister = _gnuradio_swig_py_general.gr_feedforward_agc_cc_sptr_swigregister
gr_feedforward_agc_cc_sptr_swigregister(gr_feedforward_agc_cc_sptr)

def ctcss_squelch_ff(*args):
  """
    ctcss_squelch_ff(int rate, float freq, float level = 0.01, int len = 0, 
        int ramp = 0, bool gate = False) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level = 0.01, int len = 0, 
        int ramp = 0) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level = 0.01, int len = 0) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level = 0.01) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq) -> gr_ctcss_squelch_ff_sptr
    """
  return _gnuradio_swig_py_general.ctcss_squelch_ff(*args)


def gr_feedforward_agc_cc_block(*args):
  """gr_feedforward_agc_cc_block(gr_feedforward_agc_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_feedforward_agc_cc_block(*args)
gr_feedforward_agc_cc_sptr.block = lambda self: gr_feedforward_agc_cc_block (self)
gr_feedforward_agc_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_bin_statistics_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_bin_statistics_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__(self) -> gr_bin_statistics_f_sptr
        __init__(self,  p) -> gr_bin_statistics_f_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_bin_statistics_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_bin_statistics_f_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_check_topology(self, *args)

gr_bin_statistics_f_sptr_swigregister = _gnuradio_swig_py_general.gr_bin_statistics_f_sptr_swigregister
gr_bin_statistics_f_sptr_swigregister(gr_bin_statistics_f_sptr)

def feedforward_agc_cc(*args):
  """
    feedforward_agc_cc(int nsamples, float reference = 1.0) -> gr_feedforward_agc_cc_sptr
    feedforward_agc_cc(int nsamples) -> gr_feedforward_agc_cc_sptr
    """
  return _gnuradio_swig_py_general.feedforward_agc_cc(*args)


def gr_bin_statistics_f_block(*args):
  """gr_bin_statistics_f_block(gr_bin_statistics_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_bin_statistics_f_block(*args)
gr_bin_statistics_f_sptr.block = lambda self: gr_bin_statistics_f_block (self)
gr_bin_statistics_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def bin_statistics_f(*args):
  """
    bin_statistics_f(unsigned int vlen, gr_msg_queue_sptr msgq,  tune, size_t tune_delay, 
        size_t dwell_delay) -> gr_bin_statistics_f_sptr
    """
  return _gnuradio_swig_py_general.bin_statistics_f(*args)
class gr_glfsr_source_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_glfsr_source_b_sptr
        __init__(self,  p) -> gr_glfsr_source_b_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_glfsr_source_b_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_glfsr_source_b_sptr
    __del__ = lambda self : None;
    def period(self):
        """period(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_period(self)

    def mask(self):
        """mask(self) -> int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_mask(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_check_topology(self, *args)

gr_glfsr_source_b_sptr_swigregister = _gnuradio_swig_py_general.gr_glfsr_source_b_sptr_swigregister
gr_glfsr_source_b_sptr_swigregister(gr_glfsr_source_b_sptr)


def gr_glfsr_source_b_block(*args):
  """gr_glfsr_source_b_block(gr_glfsr_source_b_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_glfsr_source_b_block(*args)
gr_glfsr_source_b_sptr.block = lambda self: gr_glfsr_source_b_block (self)
gr_glfsr_source_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_glfsr_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_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__(self) -> gr_glfsr_source_f_sptr
        __init__(self,  p) -> gr_glfsr_source_f_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_glfsr_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_glfsr_source_f_sptr
    __del__ = lambda self : None;
    def period(self):
        """period(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_period(self)

    def mask(self):
        """mask(self) -> int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_mask(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_check_topology(self, *args)

gr_glfsr_source_f_sptr_swigregister = _gnuradio_swig_py_general.gr_glfsr_source_f_sptr_swigregister
gr_glfsr_source_f_sptr_swigregister(gr_glfsr_source_f_sptr)

def glfsr_source_b(*args):
  """
    glfsr_source_b(int degree, bool repeat = True, int mask = 0, int seed = 1) -> gr_glfsr_source_b_sptr
    glfsr_source_b(int degree, bool repeat = True, int mask = 0) -> gr_glfsr_source_b_sptr
    glfsr_source_b(int degree, bool repeat = True) -> gr_glfsr_source_b_sptr
    glfsr_source_b(int degree) -> gr_glfsr_source_b_sptr
    """
  return _gnuradio_swig_py_general.glfsr_source_b(*args)


def gr_glfsr_source_f_block(*args):
  """gr_glfsr_source_f_block(gr_glfsr_source_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_glfsr_source_f_block(*args)
gr_glfsr_source_f_sptr.block = lambda self: gr_glfsr_source_f_block (self)
gr_glfsr_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_peak_detector2_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_peak_detector2_fb)> 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__(self) -> gr_peak_detector2_fb_sptr
        __init__(self,  p) -> gr_peak_detector2_fb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_peak_detector2_fb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_peak_detector2_fb_sptr
    __del__ = lambda self : None;
    def set_threshold_factor_rise(self, *args):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_set_threshold_factor_rise(self, *args)

    def set_look_ahead(self, *args):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_set_look_ahead(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_set_alpha(self, *args)

    def threshold_factor_rise(self):
        """threshold_factor_rise(self) -> float"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_threshold_factor_rise(self)

    def look_ahead(self):
        """look_ahead(self) -> int"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_look_ahead(self)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_alpha(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_check_topology(self, *args)

gr_peak_detector2_fb_sptr_swigregister = _gnuradio_swig_py_general.gr_peak_detector2_fb_sptr_swigregister
gr_peak_detector2_fb_sptr_swigregister(gr_peak_detector2_fb_sptr)

def glfsr_source_f(*args):
  """
    glfsr_source_f(int degree, bool repeat = True, int mask = 0, int seed = 1) -> gr_glfsr_source_f_sptr
    glfsr_source_f(int degree, bool repeat = True, int mask = 0) -> gr_glfsr_source_f_sptr
    glfsr_source_f(int degree, bool repeat = True) -> gr_glfsr_source_f_sptr
    glfsr_source_f(int degree) -> gr_glfsr_source_f_sptr
    """
  return _gnuradio_swig_py_general.glfsr_source_f(*args)


def gr_peak_detector2_fb_block(*args):
  """gr_peak_detector2_fb_block(gr_peak_detector2_fb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_peak_detector2_fb_block(*args)
gr_peak_detector2_fb_sptr.block = lambda self: gr_peak_detector2_fb_block (self)
gr_peak_detector2_fb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_repeat_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_repeat)> 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__(self) -> gr_repeat_sptr
        __init__(self,  p) -> gr_repeat_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_repeat_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_repeat_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_repeat_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_repeat_sptr_check_topology(self, *args)

gr_repeat_sptr_swigregister = _gnuradio_swig_py_general.gr_repeat_sptr_swigregister
gr_repeat_sptr_swigregister(gr_repeat_sptr)

def peak_detector2_fb(threshold_factor_rise = 7, look_ahead = 1000, alpha = 0.001):
  """
    peak_detector2_fb(float threshold_factor_rise = 7, int look_ahead = 1000, 
        float alpha = 0.001) -> gr_peak_detector2_fb_sptr
    peak_detector2_fb(float threshold_factor_rise = 7, int look_ahead = 1000) -> gr_peak_detector2_fb_sptr
    peak_detector2_fb(float threshold_factor_rise = 7) -> gr_peak_detector2_fb_sptr
    peak_detector2_fb() -> gr_peak_detector2_fb_sptr
    """
  return _gnuradio_swig_py_general.peak_detector2_fb(threshold_factor_rise, look_ahead, alpha)


def gr_repeat_block(*args):
  """gr_repeat_block(gr_repeat_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_repeat_block(*args)
gr_repeat_sptr.block = lambda self: gr_repeat_block (self)
gr_repeat_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def repeat(*args):
  """repeat(size_t itemsize, int interp) -> gr_repeat_sptr"""
  return _gnuradio_swig_py_general.repeat(*args)
class gr_cpfsk_bc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_cpfsk_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__(self) -> gr_cpfsk_bc_sptr
        __init__(self,  p) -> gr_cpfsk_bc_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_cpfsk_bc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_cpfsk_bc_sptr
    __del__ = lambda self : None;
    def set_amplitude(self, *args):
        """set_amplitude(self, float amplitude)"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_set_amplitude(self, *args)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_check_topology(self, *args)

gr_cpfsk_bc_sptr_swigregister = _gnuradio_swig_py_general.gr_cpfsk_bc_sptr_swigregister
gr_cpfsk_bc_sptr_swigregister(gr_cpfsk_bc_sptr)


def gr_cpfsk_bc_block(*args):
  """gr_cpfsk_bc_block(gr_cpfsk_bc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_cpfsk_bc_block(*args)
gr_cpfsk_bc_sptr.block = lambda self: gr_cpfsk_bc_block (self)
gr_cpfsk_bc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def cpfsk_bc(*args):
  """cpfsk_bc(float k, float ampl, int samples_per_sym) -> gr_cpfsk_bc_sptr"""
  return _gnuradio_swig_py_general.cpfsk_bc(*args)
class gr_encode_ccsds_27_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_encode_ccsds_27_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__(self) -> gr_encode_ccsds_27_bb_sptr
        __init__(self,  p) -> gr_encode_ccsds_27_bb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_encode_ccsds_27_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_encode_ccsds_27_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_check_topology(self, *args)

gr_encode_ccsds_27_bb_sptr_swigregister = _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_sptr_swigregister
gr_encode_ccsds_27_bb_sptr_swigregister(gr_encode_ccsds_27_bb_sptr)


def gr_encode_ccsds_27_bb_block(*args):
  """gr_encode_ccsds_27_bb_block(gr_encode_ccsds_27_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_encode_ccsds_27_bb_block(*args)
gr_encode_ccsds_27_bb_sptr.block = lambda self: gr_encode_ccsds_27_bb_block (self)
gr_encode_ccsds_27_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def encode_ccsds_27_bb():
  """encode_ccsds_27_bb() -> gr_encode_ccsds_27_bb_sptr"""
  return _gnuradio_swig_py_general.encode_ccsds_27_bb()
class gr_decode_ccsds_27_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_decode_ccsds_27_fb)> 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__(self) -> gr_decode_ccsds_27_fb_sptr
        __init__(self,  p) -> gr_decode_ccsds_27_fb_sptr
        """
        this = _gnuradio_swig_py_general.new_gr_decode_ccsds_27_fb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_general.delete_gr_decode_ccsds_27_fb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_basic_block(self)

    def check_topology(self, *args):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_check_topology(self, *args)

gr_decode_ccsds_27_fb_sptr_swigregister = _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_sptr_swigregister
gr_decode_ccsds_27_fb_sptr_swigregister(gr_decode_ccsds_27_fb_sptr)


def gr_decode_ccsds_27_fb_block(*args):
  """gr_decode_ccsds_27_fb_block(gr_decode_ccsds_27_fb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_general.gr_decode_ccsds_27_fb_block(*args)
gr_decode_ccsds_27_fb_sptr.block = lambda self: gr_decode_ccsds_27_fb_block (self)
gr_decode_ccsds_27_fb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def decode_ccsds_27_fb():
  """decode_ccsds_27_fb() -> gr_decode_ccsds_27_fb_sptr"""
  return _gnuradio_swig_py_general.decode_ccsds_27_fb()


