# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# 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_gengen', [dirname(__file__)])
        except ImportError:
            import _gnuradio_swig_py_gengen
            return _gnuradio_swig_py_gengen
        if fp is not None:
            try:
                _mod = imp.load_module('_gnuradio_swig_py_gengen', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gnuradio_swig_py_gengen = swig_import_helper()
    del swig_import_helper
else:
    import _gnuradio_swig_py_gengen
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


class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """incr(self, size_t n = 1) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """decr(self, size_t n = 1) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_decr(self, n)

    def distance(self, *args, **kwargs):
        """distance(self, SwigPyIterator x) -> ptrdiff_t"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_distance(self, *args, **kwargs)

    def equal(self, *args, **kwargs):
        """equal(self, SwigPyIterator x) -> bool"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_equal(self, *args, **kwargs)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_previous(self)

    def advance(self, *args, **kwargs):
        """advance(self, ptrdiff_t n) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator_advance(self, *args, **kwargs)

    def __eq__(self, *args, **kwargs):
        """__eq__(self, SwigPyIterator x) -> bool"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___eq__(self, *args, **kwargs)

    def __ne__(self, *args, **kwargs):
        """__ne__(self, SwigPyIterator x) -> bool"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___ne__(self, *args, **kwargs)

    def __iadd__(self, *args, **kwargs):
        """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___iadd__(self, *args, **kwargs)

    def __isub__(self, *args, **kwargs):
        """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___isub__(self, *args, **kwargs)

    def __add__(self, *args, **kwargs):
        """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _gnuradio_swig_py_gengen.SwigPyIterator___add__(self, *args, **kwargs)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(self, SwigPyIterator x) -> ptrdiff_t
        """
        return _gnuradio_swig_py_gengen.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _gnuradio_swig_py_gengen.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

sizeof_char = _gnuradio_swig_py_gengen.sizeof_char
sizeof_short = _gnuradio_swig_py_gengen.sizeof_short
sizeof_int = _gnuradio_swig_py_gengen.sizeof_int
sizeof_float = _gnuradio_swig_py_gengen.sizeof_float
sizeof_double = _gnuradio_swig_py_gengen.sizeof_double
sizeof_gr_complex = _gnuradio_swig_py_gengen.sizeof_gr_complex
GR_MSB_FIRST = _gnuradio_swig_py_gengen.GR_MSB_FIRST
GR_LSB_FIRST = _gnuradio_swig_py_gengen.GR_LSB_FIRST
GR_CONST_WAVE = _gnuradio_swig_py_gengen.GR_CONST_WAVE
GR_SIN_WAVE = _gnuradio_swig_py_gengen.GR_SIN_WAVE
GR_COS_WAVE = _gnuradio_swig_py_gengen.GR_COS_WAVE
GR_SQR_WAVE = _gnuradio_swig_py_gengen.GR_SQR_WAVE
GR_TRI_WAVE = _gnuradio_swig_py_gengen.GR_TRI_WAVE
GR_SAW_WAVE = _gnuradio_swig_py_gengen.GR_SAW_WAVE
GR_UNIFORM = _gnuradio_swig_py_gengen.GR_UNIFORM
GR_GAUSSIAN = _gnuradio_swig_py_gengen.GR_GAUSSIAN
GR_LAPLACIAN = _gnuradio_swig_py_gengen.GR_LAPLACIAN
GR_IMPULSE = _gnuradio_swig_py_gengen.GR_IMPULSE
class gr_add_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_add_cc_sptr
        __init__(self,  p) -> gr_add_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_check_topology(self, *args, **kwargs)

gr_add_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_cc_sptr_swigregister
gr_add_cc_sptr_swigregister(gr_add_cc_sptr)

gr_add_cc_sptr.block = lambda self: gr_add_cc_block (self)
gr_add_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_cc(vlen = 1):
  """add_cc(size_t vlen = 1) -> gr_add_cc_sptr"""
  return _gnuradio_swig_py_gengen.add_cc(vlen)
class gr_add_const_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_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_add_const_cc_sptr
        __init__(self,  p) -> gr_add_const_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_cc_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> gr_complex"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, gr_complex k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_check_topology(self, *args, **kwargs)

gr_add_const_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_swigregister
gr_add_const_cc_sptr_swigregister(gr_add_const_cc_sptr)

gr_add_const_cc_sptr.block = lambda self: gr_add_const_cc_block (self)
gr_add_const_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_cc(*args, **kwargs):
  """add_const_cc(gr_complex k) -> gr_add_const_cc_sptr"""
  return _gnuradio_swig_py_gengen.add_const_cc(*args, **kwargs)
class gr_add_const_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_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_add_const_ff_sptr
        __init__(self,  p) -> gr_add_const_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_ff_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, float k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_check_topology(self, *args, **kwargs)

gr_add_const_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_swigregister
gr_add_const_ff_sptr_swigregister(gr_add_const_ff_sptr)

gr_add_const_ff_sptr.block = lambda self: gr_add_const_ff_block (self)
gr_add_const_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_ff(*args, **kwargs):
  """add_const_ff(float k) -> gr_add_const_ff_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ff(*args, **kwargs)
class gr_add_const_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_ii)> 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_add_const_ii_sptr
        __init__(self,  p) -> gr_add_const_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_ii_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, int k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_check_topology(self, *args, **kwargs)

gr_add_const_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_swigregister
gr_add_const_ii_sptr_swigregister(gr_add_const_ii_sptr)

gr_add_const_ii_sptr.block = lambda self: gr_add_const_ii_block (self)
gr_add_const_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_ii(*args, **kwargs):
  """add_const_ii(int k) -> gr_add_const_ii_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ii(*args, **kwargs)
class gr_add_const_sf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_sf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_sf_sptr
        __init__(self,  p) -> gr_add_const_sf_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_sf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_sf_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_check_topology(self, *args, **kwargs)

gr_add_const_sf_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_swigregister
gr_add_const_sf_sptr_swigregister(gr_add_const_sf_sptr)

gr_add_const_sf_sptr.block = lambda self: gr_add_const_sf_block (self)
gr_add_const_sf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_sf(*args, **kwargs):
  """add_const_sf(short k) -> gr_add_const_sf_sptr"""
  return _gnuradio_swig_py_gengen.add_const_sf(*args, **kwargs)
class gr_add_const_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_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_add_const_ss_sptr
        __init__(self,  p) -> gr_add_const_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_ss_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_check_topology(self, *args, **kwargs)

gr_add_const_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_swigregister
gr_add_const_ss_sptr_swigregister(gr_add_const_ss_sptr)

gr_add_const_ss_sptr.block = lambda self: gr_add_const_ss_block (self)
gr_add_const_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_ss(*args, **kwargs):
  """add_const_ss(short k) -> gr_add_const_ss_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ss(*args, **kwargs)
class gr_add_const_vcc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_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_add_const_vcc_sptr
        __init__(self,  p) -> gr_add_const_vcc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_vcc_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_check_topology(self, *args, **kwargs)

gr_add_const_vcc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_swigregister
gr_add_const_vcc_sptr_swigregister(gr_add_const_vcc_sptr)

gr_add_const_vcc_sptr.block = lambda self: gr_add_const_vcc_block (self)
gr_add_const_vcc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_vcc(*args, **kwargs):
  """add_const_vcc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> k) -> gr_add_const_vcc_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vcc(*args, **kwargs)
class gr_add_const_vff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_vff)> 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_add_const_vff_sptr
        __init__(self,  p) -> gr_add_const_vff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_vff_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_4__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_check_topology(self, *args, **kwargs)

gr_add_const_vff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_swigregister
gr_add_const_vff_sptr_swigregister(gr_add_const_vff_sptr)

gr_add_const_vff_sptr.block = lambda self: gr_add_const_vff_block (self)
gr_add_const_vff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_vff(*args, **kwargs):
  """add_const_vff(__dummy_4__ k) -> gr_add_const_vff_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vff(*args, **kwargs)
class gr_add_const_vii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_vii)> 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_add_const_vii_sptr
        __init__(self,  p) -> gr_add_const_vii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_vii_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_3__"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_3__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_check_topology(self, *args, **kwargs)

gr_add_const_vii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_swigregister
gr_add_const_vii_sptr_swigregister(gr_add_const_vii_sptr)

gr_add_const_vii_sptr.block = lambda self: gr_add_const_vii_block (self)
gr_add_const_vii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_vii(*args, **kwargs):
  """add_const_vii(__dummy_3__ k) -> gr_add_const_vii_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vii(*args, **kwargs)
class gr_add_const_vss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_const_vss)> 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_add_const_vss_sptr
        __init__(self,  p) -> gr_add_const_vss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_const_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_const_vss_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_2__"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_2__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_check_topology(self, *args, **kwargs)

gr_add_const_vss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_swigregister
gr_add_const_vss_sptr_swigregister(gr_add_const_vss_sptr)

gr_add_const_vss_sptr.block = lambda self: gr_add_const_vss_block (self)
gr_add_const_vss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_const_vss(*args, **kwargs):
  """add_const_vss(__dummy_2__ k) -> gr_add_const_vss_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vss(*args, **kwargs)
class gr_add_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_add_ff_sptr
        __init__(self,  p) -> gr_add_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_check_topology(self, *args, **kwargs)

gr_add_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ff_sptr_swigregister
gr_add_ff_sptr_swigregister(gr_add_ff_sptr)

gr_add_ff_sptr.block = lambda self: gr_add_ff_block (self)
gr_add_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_ff(vlen = 1):
  """add_ff(size_t vlen = 1) -> gr_add_ff_sptr"""
  return _gnuradio_swig_py_gengen.add_ff(vlen)
class gr_add_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_ii)> 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_add_ii_sptr
        __init__(self,  p) -> gr_add_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_check_topology(self, *args, **kwargs)

gr_add_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ii_sptr_swigregister
gr_add_ii_sptr_swigregister(gr_add_ii_sptr)

gr_add_ii_sptr.block = lambda self: gr_add_ii_block (self)
gr_add_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_ii(vlen = 1):
  """add_ii(size_t vlen = 1) -> gr_add_ii_sptr"""
  return _gnuradio_swig_py_gengen.add_ii(vlen)
class gr_add_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_add_ss_sptr
        __init__(self,  p) -> gr_add_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_add_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_check_topology(self, *args, **kwargs)

gr_add_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ss_sptr_swigregister
gr_add_ss_sptr_swigregister(gr_add_ss_sptr)

gr_add_ss_sptr.block = lambda self: gr_add_ss_block (self)
gr_add_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def add_ss(vlen = 1):
  """add_ss(size_t vlen = 1) -> gr_add_ss_sptr"""
  return _gnuradio_swig_py_gengen.add_ss(vlen)
class gr_and_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_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_and_bb_sptr
        __init__(self,  p) -> gr_and_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_check_topology(self, *args, **kwargs)

gr_and_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_bb_sptr_swigregister
gr_and_bb_sptr_swigregister(gr_and_bb_sptr)

gr_and_bb_sptr.block = lambda self: gr_and_bb_block (self)
gr_and_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_bb():
  """and_bb() -> gr_and_bb_sptr"""
  return _gnuradio_swig_py_gengen.and_bb()
class gr_and_const_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_const_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_and_const_bb_sptr
        __init__(self,  p) -> gr_and_const_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_const_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_const_bb_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> unsigned char"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, unsigned char k)"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_check_topology(self, *args, **kwargs)

gr_and_const_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_const_bb_sptr_swigregister
gr_and_const_bb_sptr_swigregister(gr_and_const_bb_sptr)

gr_and_const_bb_sptr.block = lambda self: gr_and_const_bb_block (self)
gr_and_const_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_const_bb(*args, **kwargs):
  """and_const_bb(unsigned char k) -> gr_and_const_bb_sptr"""
  return _gnuradio_swig_py_gengen.and_const_bb(*args, **kwargs)
class gr_and_const_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_const_ii)> 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_and_const_ii_sptr
        __init__(self,  p) -> gr_and_const_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_const_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_const_ii_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, int k)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_check_topology(self, *args, **kwargs)

gr_and_const_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_const_ii_sptr_swigregister
gr_and_const_ii_sptr_swigregister(gr_and_const_ii_sptr)

gr_and_const_ii_sptr.block = lambda self: gr_and_const_ii_block (self)
gr_and_const_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_const_ii(*args, **kwargs):
  """and_const_ii(int k) -> gr_and_const_ii_sptr"""
  return _gnuradio_swig_py_gengen.and_const_ii(*args, **kwargs)
class gr_and_const_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_const_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_and_const_ss_sptr
        __init__(self,  p) -> gr_and_const_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_const_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_const_ss_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_check_topology(self, *args, **kwargs)

gr_and_const_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_const_ss_sptr_swigregister
gr_and_const_ss_sptr_swigregister(gr_and_const_ss_sptr)

gr_and_const_ss_sptr.block = lambda self: gr_and_const_ss_block (self)
gr_and_const_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_const_ss(*args, **kwargs):
  """and_const_ss(short k) -> gr_and_const_ss_sptr"""
  return _gnuradio_swig_py_gengen.and_const_ss(*args, **kwargs)
class gr_and_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_ii)> 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_and_ii_sptr
        __init__(self,  p) -> gr_and_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_check_topology(self, *args, **kwargs)

gr_and_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_ii_sptr_swigregister
gr_and_ii_sptr_swigregister(gr_and_ii_sptr)

gr_and_ii_sptr.block = lambda self: gr_and_ii_block (self)
gr_and_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_ii():
  """and_ii() -> gr_and_ii_sptr"""
  return _gnuradio_swig_py_gengen.and_ii()
class gr_and_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_and_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_and_ss_sptr
        __init__(self,  p) -> gr_and_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_and_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_and_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_check_topology(self, *args, **kwargs)

gr_and_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_ss_sptr_swigregister
gr_and_ss_sptr_swigregister(gr_and_ss_sptr)

gr_and_ss_sptr.block = lambda self: gr_and_ss_block (self)
gr_and_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def and_ss():
  """and_ss() -> gr_and_ss_sptr"""
  return _gnuradio_swig_py_gengen.and_ss()
class gr_argmax_fs_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_argmax_fs)> 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_argmax_fs_sptr
        __init__(self,  p) -> gr_argmax_fs_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_argmax_fs_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_argmax_fs_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_check_topology(self, *args, **kwargs)

gr_argmax_fs_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_swigregister
gr_argmax_fs_sptr_swigregister(gr_argmax_fs_sptr)

gr_argmax_fs_sptr.block = lambda self: gr_argmax_fs_block (self)
gr_argmax_fs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def argmax_fs(*args, **kwargs):
  """argmax_fs(size_t vlen) -> gr_argmax_fs_sptr"""
  return _gnuradio_swig_py_gengen.argmax_fs(*args, **kwargs)
class gr_argmax_is_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_argmax_is)> 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_argmax_is_sptr
        __init__(self,  p) -> gr_argmax_is_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_argmax_is_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_argmax_is_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_check_topology(self, *args, **kwargs)

gr_argmax_is_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_is_sptr_swigregister
gr_argmax_is_sptr_swigregister(gr_argmax_is_sptr)

gr_argmax_is_sptr.block = lambda self: gr_argmax_is_block (self)
gr_argmax_is_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def argmax_is(*args, **kwargs):
  """argmax_is(size_t vlen) -> gr_argmax_is_sptr"""
  return _gnuradio_swig_py_gengen.argmax_is(*args, **kwargs)
class gr_argmax_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_argmax_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_argmax_ss_sptr
        __init__(self,  p) -> gr_argmax_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_argmax_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_argmax_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_check_topology(self, *args, **kwargs)

gr_argmax_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_swigregister
gr_argmax_ss_sptr_swigregister(gr_argmax_ss_sptr)

gr_argmax_ss_sptr.block = lambda self: gr_argmax_ss_block (self)
gr_argmax_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def argmax_ss(*args, **kwargs):
  """argmax_ss(size_t vlen) -> gr_argmax_ss_sptr"""
  return _gnuradio_swig_py_gengen.argmax_ss(*args, **kwargs)
class gr_chunks_to_symbols_bc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_bc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_bc_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_bc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_bc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_bc_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_bc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_swigregister
gr_chunks_to_symbols_bc_sptr_swigregister(gr_chunks_to_symbols_bc_sptr)

gr_chunks_to_symbols_bc_sptr.block = lambda self: gr_chunks_to_symbols_bc_block (self)
gr_chunks_to_symbols_bc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_bc(*args, **kwargs):
  """
    chunks_to_symbols_bc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_bc_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_bc(*args, **kwargs)
class gr_chunks_to_symbols_bf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_bf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_bf_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_bf_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_bf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_bf_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_bf_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_swigregister
gr_chunks_to_symbols_bf_sptr_swigregister(gr_chunks_to_symbols_bf_sptr)

gr_chunks_to_symbols_bf_sptr.block = lambda self: gr_chunks_to_symbols_bf_block (self)
gr_chunks_to_symbols_bf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_bf(*args, **kwargs):
  """chunks_to_symbols_bf(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_bf_sptr"""
  return _gnuradio_swig_py_gengen.chunks_to_symbols_bf(*args, **kwargs)
class gr_chunks_to_symbols_ic_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_ic)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_ic_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_ic_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_ic_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_ic_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_ic_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_swigregister
gr_chunks_to_symbols_ic_sptr_swigregister(gr_chunks_to_symbols_ic_sptr)

gr_chunks_to_symbols_ic_sptr.block = lambda self: gr_chunks_to_symbols_ic_block (self)
gr_chunks_to_symbols_ic_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_ic(*args, **kwargs):
  """
    chunks_to_symbols_ic(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_ic_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_ic(*args, **kwargs)
class gr_chunks_to_symbols_if_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_if)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_if_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_if_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_if_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_if_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_if_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_swigregister
gr_chunks_to_symbols_if_sptr_swigregister(gr_chunks_to_symbols_if_sptr)

gr_chunks_to_symbols_if_sptr.block = lambda self: gr_chunks_to_symbols_if_block (self)
gr_chunks_to_symbols_if_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_if(*args, **kwargs):
  """chunks_to_symbols_if(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_if_sptr"""
  return _gnuradio_swig_py_gengen.chunks_to_symbols_if(*args, **kwargs)
class gr_chunks_to_symbols_sc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_sc)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_sc_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_sc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_sc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_sc_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_sc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_swigregister
gr_chunks_to_symbols_sc_sptr_swigregister(gr_chunks_to_symbols_sc_sptr)

gr_chunks_to_symbols_sc_sptr.block = lambda self: gr_chunks_to_symbols_sc_block (self)
gr_chunks_to_symbols_sc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_sc(*args, **kwargs):
  """
    chunks_to_symbols_sc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_sc_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_sc(*args, **kwargs)
class gr_chunks_to_symbols_sf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_chunks_to_symbols_sf)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_sf_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_sf_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_chunks_to_symbols_sf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_chunks_to_symbols_sf_sptr
    __del__ = lambda self : None;
    def D(self):
        """D(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_D(self)

    def symbol_table(self):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_symbol_table(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_check_topology(self, *args, **kwargs)

gr_chunks_to_symbols_sf_sptr_swigregister = _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_swigregister
gr_chunks_to_symbols_sf_sptr_swigregister(gr_chunks_to_symbols_sf_sptr)

gr_chunks_to_symbols_sf_sptr.block = lambda self: gr_chunks_to_symbols_sf_block (self)
gr_chunks_to_symbols_sf_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def chunks_to_symbols_sf(*args, **kwargs):
  """chunks_to_symbols_sf(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_sf_sptr"""
  return _gnuradio_swig_py_gengen.chunks_to_symbols_sf(*args, **kwargs)
class gr_divide_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_divide_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_divide_cc_sptr
        __init__(self,  p) -> gr_divide_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_divide_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_divide_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_check_topology(self, *args, **kwargs)

gr_divide_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_cc_sptr_swigregister
gr_divide_cc_sptr_swigregister(gr_divide_cc_sptr)

gr_divide_cc_sptr.block = lambda self: gr_divide_cc_block (self)
gr_divide_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def divide_cc(vlen = 1):
  """divide_cc(size_t vlen = 1) -> gr_divide_cc_sptr"""
  return _gnuradio_swig_py_gengen.divide_cc(vlen)
class gr_divide_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_divide_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_divide_ff_sptr
        __init__(self,  p) -> gr_divide_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_divide_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_divide_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_check_topology(self, *args, **kwargs)

gr_divide_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ff_sptr_swigregister
gr_divide_ff_sptr_swigregister(gr_divide_ff_sptr)

gr_divide_ff_sptr.block = lambda self: gr_divide_ff_block (self)
gr_divide_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def divide_ff(vlen = 1):
  """divide_ff(size_t vlen = 1) -> gr_divide_ff_sptr"""
  return _gnuradio_swig_py_gengen.divide_ff(vlen)
class gr_divide_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_divide_ii)> 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_divide_ii_sptr
        __init__(self,  p) -> gr_divide_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_divide_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_divide_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_check_topology(self, *args, **kwargs)

gr_divide_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ii_sptr_swigregister
gr_divide_ii_sptr_swigregister(gr_divide_ii_sptr)

gr_divide_ii_sptr.block = lambda self: gr_divide_ii_block (self)
gr_divide_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def divide_ii(vlen = 1):
  """divide_ii(size_t vlen = 1) -> gr_divide_ii_sptr"""
  return _gnuradio_swig_py_gengen.divide_ii(vlen)
class gr_divide_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_divide_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_divide_ss_sptr
        __init__(self,  p) -> gr_divide_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_divide_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_divide_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_check_topology(self, *args, **kwargs)

gr_divide_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ss_sptr_swigregister
gr_divide_ss_sptr_swigregister(gr_divide_ss_sptr)

gr_divide_ss_sptr.block = lambda self: gr_divide_ss_block (self)
gr_divide_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def divide_ss(vlen = 1):
  """divide_ss(size_t vlen = 1) -> gr_divide_ss_sptr"""
  return _gnuradio_swig_py_gengen.divide_ss(vlen)
class gr_integrate_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_integrate_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_integrate_cc_sptr
        __init__(self,  p) -> gr_integrate_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_integrate_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_integrate_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_check_topology(self, *args, **kwargs)

gr_integrate_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_swigregister
gr_integrate_cc_sptr_swigregister(gr_integrate_cc_sptr)

gr_integrate_cc_sptr.block = lambda self: gr_integrate_cc_block (self)
gr_integrate_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def integrate_cc(*args, **kwargs):
  """integrate_cc(int decim) -> gr_integrate_cc_sptr"""
  return _gnuradio_swig_py_gengen.integrate_cc(*args, **kwargs)
class gr_integrate_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_integrate_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_integrate_ff_sptr
        __init__(self,  p) -> gr_integrate_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_integrate_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_integrate_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_check_topology(self, *args, **kwargs)

gr_integrate_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_swigregister
gr_integrate_ff_sptr_swigregister(gr_integrate_ff_sptr)

gr_integrate_ff_sptr.block = lambda self: gr_integrate_ff_block (self)
gr_integrate_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def integrate_ff(*args, **kwargs):
  """integrate_ff(int decim) -> gr_integrate_ff_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ff(*args, **kwargs)
class gr_integrate_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_integrate_ii)> 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_integrate_ii_sptr
        __init__(self,  p) -> gr_integrate_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_integrate_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_integrate_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_check_topology(self, *args, **kwargs)

gr_integrate_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_swigregister
gr_integrate_ii_sptr_swigregister(gr_integrate_ii_sptr)

gr_integrate_ii_sptr.block = lambda self: gr_integrate_ii_block (self)
gr_integrate_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def integrate_ii(*args, **kwargs):
  """integrate_ii(int decim) -> gr_integrate_ii_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ii(*args, **kwargs)
class gr_integrate_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_integrate_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_integrate_ss_sptr
        __init__(self,  p) -> gr_integrate_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_integrate_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_integrate_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_check_topology(self, *args, **kwargs)

gr_integrate_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_swigregister
gr_integrate_ss_sptr_swigregister(gr_integrate_ss_sptr)

gr_integrate_ss_sptr.block = lambda self: gr_integrate_ss_block (self)
gr_integrate_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def integrate_ss(*args, **kwargs):
  """integrate_ss(int decim) -> gr_integrate_ss_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ss(*args, **kwargs)
class gr_max_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_max_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_max_ff_sptr
        __init__(self,  p) -> gr_max_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_max_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_max_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_check_topology(self, *args, **kwargs)

gr_max_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ff_sptr_swigregister
gr_max_ff_sptr_swigregister(gr_max_ff_sptr)

gr_max_ff_sptr.block = lambda self: gr_max_ff_block (self)
gr_max_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def max_ff(*args, **kwargs):
  """max_ff(size_t vlen) -> gr_max_ff_sptr"""
  return _gnuradio_swig_py_gengen.max_ff(*args, **kwargs)
class gr_max_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_max_ii)> 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_max_ii_sptr
        __init__(self,  p) -> gr_max_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_max_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_max_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_check_topology(self, *args, **kwargs)

gr_max_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ii_sptr_swigregister
gr_max_ii_sptr_swigregister(gr_max_ii_sptr)

gr_max_ii_sptr.block = lambda self: gr_max_ii_block (self)
gr_max_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def max_ii(*args, **kwargs):
  """max_ii(size_t vlen) -> gr_max_ii_sptr"""
  return _gnuradio_swig_py_gengen.max_ii(*args, **kwargs)
class gr_max_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_max_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_max_ss_sptr
        __init__(self,  p) -> gr_max_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_max_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_max_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_check_topology(self, *args, **kwargs)

gr_max_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ss_sptr_swigregister
gr_max_ss_sptr_swigregister(gr_max_ss_sptr)

gr_max_ss_sptr.block = lambda self: gr_max_ss_block (self)
gr_max_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def max_ss(*args, **kwargs):
  """max_ss(size_t vlen) -> gr_max_ss_sptr"""
  return _gnuradio_swig_py_gengen.max_ss(*args, **kwargs)
class gr_moving_average_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_moving_average_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_moving_average_cc_sptr
        __init__(self,  p) -> gr_moving_average_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_moving_average_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_moving_average_cc_sptr
    __del__ = lambda self : None;
    def length(self):
        """length(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_length(self)

    def scale(self):
        """scale(self) -> gr_complex"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_scale(self)

    def set_length_and_scale(self, *args, **kwargs):
        """set_length_and_scale(self, int length, gr_complex scale)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_set_length_and_scale(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_check_topology(self, *args, **kwargs)

gr_moving_average_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_swigregister
gr_moving_average_cc_sptr_swigregister(gr_moving_average_cc_sptr)

gr_moving_average_cc_sptr.block = lambda self: gr_moving_average_cc_block (self)
gr_moving_average_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def moving_average_cc(*args, **kwargs):
  """moving_average_cc(int length, gr_complex scale, int max_iter = 4096) -> gr_moving_average_cc_sptr"""
  return _gnuradio_swig_py_gengen.moving_average_cc(*args, **kwargs)
class gr_moving_average_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_moving_average_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_moving_average_ff_sptr
        __init__(self,  p) -> gr_moving_average_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_moving_average_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_moving_average_ff_sptr
    __del__ = lambda self : None;
    def length(self):
        """length(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_length(self)

    def scale(self):
        """scale(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_scale(self)

    def set_length_and_scale(self, *args, **kwargs):
        """set_length_and_scale(self, int length, float scale)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_set_length_and_scale(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_check_topology(self, *args, **kwargs)

gr_moving_average_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_swigregister
gr_moving_average_ff_sptr_swigregister(gr_moving_average_ff_sptr)

gr_moving_average_ff_sptr.block = lambda self: gr_moving_average_ff_block (self)
gr_moving_average_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def moving_average_ff(*args, **kwargs):
  """moving_average_ff(int length, float scale, int max_iter = 4096) -> gr_moving_average_ff_sptr"""
  return _gnuradio_swig_py_gengen.moving_average_ff(*args, **kwargs)
class gr_moving_average_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_moving_average_ii)> 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_moving_average_ii_sptr
        __init__(self,  p) -> gr_moving_average_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_moving_average_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_moving_average_ii_sptr
    __del__ = lambda self : None;
    def length(self):
        """length(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_length(self)

    def scale(self):
        """scale(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_scale(self)

    def set_length_and_scale(self, *args, **kwargs):
        """set_length_and_scale(self, int length, int scale)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_set_length_and_scale(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_check_topology(self, *args, **kwargs)

gr_moving_average_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_swigregister
gr_moving_average_ii_sptr_swigregister(gr_moving_average_ii_sptr)

gr_moving_average_ii_sptr.block = lambda self: gr_moving_average_ii_block (self)
gr_moving_average_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def moving_average_ii(*args, **kwargs):
  """moving_average_ii(int length, int scale, int max_iter = 4096) -> gr_moving_average_ii_sptr"""
  return _gnuradio_swig_py_gengen.moving_average_ii(*args, **kwargs)
class gr_moving_average_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_moving_average_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_moving_average_ss_sptr
        __init__(self,  p) -> gr_moving_average_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_moving_average_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_moving_average_ss_sptr
    __del__ = lambda self : None;
    def length(self):
        """length(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_length(self)

    def scale(self):
        """scale(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_scale(self)

    def set_length_and_scale(self, *args, **kwargs):
        """set_length_and_scale(self, int length, short scale)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_set_length_and_scale(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_check_topology(self, *args, **kwargs)

gr_moving_average_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_swigregister
gr_moving_average_ss_sptr_swigregister(gr_moving_average_ss_sptr)

gr_moving_average_ss_sptr.block = lambda self: gr_moving_average_ss_block (self)
gr_moving_average_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def moving_average_ss(*args, **kwargs):
  """moving_average_ss(int length, short scale, int max_iter = 4096) -> gr_moving_average_ss_sptr"""
  return _gnuradio_swig_py_gengen.moving_average_ss(*args, **kwargs)
class gr_multiply_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_multiply_cc_sptr
        __init__(self,  p) -> gr_multiply_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_check_topology(self, *args, **kwargs)

gr_multiply_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_swigregister
gr_multiply_cc_sptr_swigregister(gr_multiply_cc_sptr)

gr_multiply_cc_sptr.block = lambda self: gr_multiply_cc_block (self)
gr_multiply_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_cc(vlen = 1):
  """multiply_cc(size_t vlen = 1) -> gr_multiply_cc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_cc(vlen)
class gr_multiply_const_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_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_multiply_const_cc_sptr
        __init__(self,  p) -> gr_multiply_const_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_cc_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> gr_complex"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, gr_complex k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_swigregister
gr_multiply_const_cc_sptr_swigregister(gr_multiply_const_cc_sptr)

gr_multiply_const_cc_sptr.block = lambda self: gr_multiply_const_cc_block (self)
gr_multiply_const_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_cc(*args, **kwargs):
  """multiply_const_cc(gr_complex k) -> gr_multiply_const_cc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_cc(*args, **kwargs)
class gr_multiply_const_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_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_multiply_const_ff_sptr
        __init__(self,  p) -> gr_multiply_const_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_ff_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, float k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_swigregister
gr_multiply_const_ff_sptr_swigregister(gr_multiply_const_ff_sptr)

gr_multiply_const_ff_sptr.block = lambda self: gr_multiply_const_ff_block (self)
gr_multiply_const_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_ff(*args, **kwargs):
  """multiply_const_ff(float k) -> gr_multiply_const_ff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ff(*args, **kwargs)
class gr_multiply_const_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_ii)> 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_multiply_const_ii_sptr
        __init__(self,  p) -> gr_multiply_const_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_ii_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, int k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_swigregister
gr_multiply_const_ii_sptr_swigregister(gr_multiply_const_ii_sptr)

gr_multiply_const_ii_sptr.block = lambda self: gr_multiply_const_ii_block (self)
gr_multiply_const_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_ii(*args, **kwargs):
  """multiply_const_ii(int k) -> gr_multiply_const_ii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ii(*args, **kwargs)
class gr_multiply_const_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_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_multiply_const_ss_sptr
        __init__(self,  p) -> gr_multiply_const_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_ss_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_swigregister
gr_multiply_const_ss_sptr_swigregister(gr_multiply_const_ss_sptr)

gr_multiply_const_ss_sptr.block = lambda self: gr_multiply_const_ss_block (self)
gr_multiply_const_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_ss(*args, **kwargs):
  """multiply_const_ss(short k) -> gr_multiply_const_ss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ss(*args, **kwargs)
class gr_multiply_const_vcc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_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_multiply_const_vcc_sptr
        __init__(self,  p) -> gr_multiply_const_vcc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_vcc_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_vcc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_swigregister
gr_multiply_const_vcc_sptr_swigregister(gr_multiply_const_vcc_sptr)

gr_multiply_const_vcc_sptr.block = lambda self: gr_multiply_const_vcc_block (self)
gr_multiply_const_vcc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_vcc(*args, **kwargs):
  """multiply_const_vcc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> k) -> gr_multiply_const_vcc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vcc(*args, **kwargs)
class gr_multiply_const_vff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_vff)> 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_multiply_const_vff_sptr
        __init__(self,  p) -> gr_multiply_const_vff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_vff_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_4__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_vff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_swigregister
gr_multiply_const_vff_sptr_swigregister(gr_multiply_const_vff_sptr)

gr_multiply_const_vff_sptr.block = lambda self: gr_multiply_const_vff_block (self)
gr_multiply_const_vff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_vff(*args, **kwargs):
  """multiply_const_vff(__dummy_4__ k) -> gr_multiply_const_vff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vff(*args, **kwargs)
class gr_multiply_const_vii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_vii)> 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_multiply_const_vii_sptr
        __init__(self,  p) -> gr_multiply_const_vii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_vii_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_3__"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_3__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_vii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_swigregister
gr_multiply_const_vii_sptr_swigregister(gr_multiply_const_vii_sptr)

gr_multiply_const_vii_sptr.block = lambda self: gr_multiply_const_vii_block (self)
gr_multiply_const_vii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_vii(*args, **kwargs):
  """multiply_const_vii(__dummy_3__ k) -> gr_multiply_const_vii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vii(*args, **kwargs)
class gr_multiply_const_vss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_const_vss)> 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_multiply_const_vss_sptr
        __init__(self,  p) -> gr_multiply_const_vss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_const_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_const_vss_sptr
    __del__ = lambda self : None;
    def k(self):
        """k(self) -> __dummy_2__"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_k(self)

    def set_k(self, *args, **kwargs):
        """set_k(self, __dummy_2__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_set_k(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_check_topology(self, *args, **kwargs)

gr_multiply_const_vss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_swigregister
gr_multiply_const_vss_sptr_swigregister(gr_multiply_const_vss_sptr)

gr_multiply_const_vss_sptr.block = lambda self: gr_multiply_const_vss_block (self)
gr_multiply_const_vss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_const_vss(*args, **kwargs):
  """multiply_const_vss(__dummy_2__ k) -> gr_multiply_const_vss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vss(*args, **kwargs)
class gr_multiply_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_multiply_ff_sptr
        __init__(self,  p) -> gr_multiply_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_check_topology(self, *args, **kwargs)

gr_multiply_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_swigregister
gr_multiply_ff_sptr_swigregister(gr_multiply_ff_sptr)

gr_multiply_ff_sptr.block = lambda self: gr_multiply_ff_block (self)
gr_multiply_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_ff(vlen = 1):
  """multiply_ff(size_t vlen = 1) -> gr_multiply_ff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ff(vlen)
class gr_multiply_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_ii)> 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_multiply_ii_sptr
        __init__(self,  p) -> gr_multiply_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_check_topology(self, *args, **kwargs)

gr_multiply_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_swigregister
gr_multiply_ii_sptr_swigregister(gr_multiply_ii_sptr)

gr_multiply_ii_sptr.block = lambda self: gr_multiply_ii_block (self)
gr_multiply_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_ii(vlen = 1):
  """multiply_ii(size_t vlen = 1) -> gr_multiply_ii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ii(vlen)
class gr_multiply_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_multiply_ss_sptr
        __init__(self,  p) -> gr_multiply_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_multiply_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_check_topology(self, *args, **kwargs)

gr_multiply_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_swigregister
gr_multiply_ss_sptr_swigregister(gr_multiply_ss_sptr)

gr_multiply_ss_sptr.block = lambda self: gr_multiply_ss_block (self)
gr_multiply_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def multiply_ss(vlen = 1):
  """multiply_ss(size_t vlen = 1) -> gr_multiply_ss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ss(vlen)
class gr_mute_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_mute_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_mute_cc_sptr
        __init__(self,  p) -> gr_mute_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_mute_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_mute_cc_sptr
    __del__ = lambda self : None;
    def mute(self):
        """mute(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_mute(self)

    def set_mute(self, *args, **kwargs):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_set_mute(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_check_topology(self, *args, **kwargs)

gr_mute_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_cc_sptr_swigregister
gr_mute_cc_sptr_swigregister(gr_mute_cc_sptr)

gr_mute_cc_sptr.block = lambda self: gr_mute_cc_block (self)
gr_mute_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def mute_cc(mute = False):
  """mute_cc(bool mute = False) -> gr_mute_cc_sptr"""
  return _gnuradio_swig_py_gengen.mute_cc(mute)
class gr_mute_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_mute_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_mute_ff_sptr
        __init__(self,  p) -> gr_mute_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_mute_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_mute_ff_sptr
    __del__ = lambda self : None;
    def mute(self):
        """mute(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_mute(self)

    def set_mute(self, *args, **kwargs):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_set_mute(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_check_topology(self, *args, **kwargs)

gr_mute_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ff_sptr_swigregister
gr_mute_ff_sptr_swigregister(gr_mute_ff_sptr)

gr_mute_ff_sptr.block = lambda self: gr_mute_ff_block (self)
gr_mute_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def mute_ff(mute = False):
  """mute_ff(bool mute = False) -> gr_mute_ff_sptr"""
  return _gnuradio_swig_py_gengen.mute_ff(mute)
class gr_mute_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_mute_ii)> 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_mute_ii_sptr
        __init__(self,  p) -> gr_mute_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_mute_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_mute_ii_sptr
    __del__ = lambda self : None;
    def mute(self):
        """mute(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_mute(self)

    def set_mute(self, *args, **kwargs):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_set_mute(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_check_topology(self, *args, **kwargs)

gr_mute_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ii_sptr_swigregister
gr_mute_ii_sptr_swigregister(gr_mute_ii_sptr)

gr_mute_ii_sptr.block = lambda self: gr_mute_ii_block (self)
gr_mute_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def mute_ii(mute = False):
  """mute_ii(bool mute = False) -> gr_mute_ii_sptr"""
  return _gnuradio_swig_py_gengen.mute_ii(mute)
class gr_mute_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_mute_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_mute_ss_sptr
        __init__(self,  p) -> gr_mute_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_mute_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_mute_ss_sptr
    __del__ = lambda self : None;
    def mute(self):
        """mute(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_mute(self)

    def set_mute(self, *args, **kwargs):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_set_mute(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_check_topology(self, *args, **kwargs)

gr_mute_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ss_sptr_swigregister
gr_mute_ss_sptr_swigregister(gr_mute_ss_sptr)

gr_mute_ss_sptr.block = lambda self: gr_mute_ss_block (self)
gr_mute_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def mute_ss(mute = False):
  """mute_ss(bool mute = False) -> gr_mute_ss_sptr"""
  return _gnuradio_swig_py_gengen.mute_ss(mute)
class gr_noise_source_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_noise_source_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_noise_source_c_sptr
        __init__(self,  p) -> gr_noise_source_c_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_noise_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_noise_source_c_sptr
    __del__ = lambda self : None;
    def set_type(self, *args, **kwargs):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_type(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_amplitude(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_check_topology(self, *args, **kwargs)

gr_noise_source_c_sptr_swigregister = _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_swigregister
gr_noise_source_c_sptr_swigregister(gr_noise_source_c_sptr)

gr_noise_source_c_sptr.block = lambda self: gr_noise_source_c_block (self)
gr_noise_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def noise_source_c(*args, **kwargs):
  """noise_source_c(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_c_sptr"""
  return _gnuradio_swig_py_gengen.noise_source_c(*args, **kwargs)
class gr_noise_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_noise_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_noise_source_f_sptr
        __init__(self,  p) -> gr_noise_source_f_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_noise_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_noise_source_f_sptr
    __del__ = lambda self : None;
    def set_type(self, *args, **kwargs):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_type(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_amplitude(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_check_topology(self, *args, **kwargs)

gr_noise_source_f_sptr_swigregister = _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_swigregister
gr_noise_source_f_sptr_swigregister(gr_noise_source_f_sptr)

gr_noise_source_f_sptr.block = lambda self: gr_noise_source_f_block (self)
gr_noise_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def noise_source_f(*args, **kwargs):
  """noise_source_f(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_f_sptr"""
  return _gnuradio_swig_py_gengen.noise_source_f(*args, **kwargs)
class gr_noise_source_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_noise_source_i)> 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_noise_source_i_sptr
        __init__(self,  p) -> gr_noise_source_i_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_noise_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_noise_source_i_sptr
    __del__ = lambda self : None;
    def set_type(self, *args, **kwargs):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_type(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_amplitude(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_check_topology(self, *args, **kwargs)

gr_noise_source_i_sptr_swigregister = _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_swigregister
gr_noise_source_i_sptr_swigregister(gr_noise_source_i_sptr)

gr_noise_source_i_sptr.block = lambda self: gr_noise_source_i_block (self)
gr_noise_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def noise_source_i(*args, **kwargs):
  """noise_source_i(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_i_sptr"""
  return _gnuradio_swig_py_gengen.noise_source_i(*args, **kwargs)
class gr_noise_source_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_noise_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_noise_source_s_sptr
        __init__(self,  p) -> gr_noise_source_s_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_noise_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_noise_source_s_sptr
    __del__ = lambda self : None;
    def set_type(self, *args, **kwargs):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_type(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_amplitude(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_check_topology(self, *args, **kwargs)

gr_noise_source_s_sptr_swigregister = _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_swigregister
gr_noise_source_s_sptr_swigregister(gr_noise_source_s_sptr)

gr_noise_source_s_sptr.block = lambda self: gr_noise_source_s_block (self)
gr_noise_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def noise_source_s(*args, **kwargs):
  """noise_source_s(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_s_sptr"""
  return _gnuradio_swig_py_gengen.noise_source_s(*args, **kwargs)
class gr_not_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_not_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_not_bb_sptr
        __init__(self,  p) -> gr_not_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_not_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_not_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_check_topology(self, *args, **kwargs)

gr_not_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_bb_sptr_swigregister
gr_not_bb_sptr_swigregister(gr_not_bb_sptr)

gr_not_bb_sptr.block = lambda self: gr_not_bb_block (self)
gr_not_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def not_bb():
  """not_bb() -> gr_not_bb_sptr"""
  return _gnuradio_swig_py_gengen.not_bb()
class gr_not_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_not_ii)> 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_not_ii_sptr
        __init__(self,  p) -> gr_not_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_not_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_not_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_check_topology(self, *args, **kwargs)

gr_not_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_ii_sptr_swigregister
gr_not_ii_sptr_swigregister(gr_not_ii_sptr)

gr_not_ii_sptr.block = lambda self: gr_not_ii_block (self)
gr_not_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def not_ii():
  """not_ii() -> gr_not_ii_sptr"""
  return _gnuradio_swig_py_gengen.not_ii()
class gr_not_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_not_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_not_ss_sptr
        __init__(self,  p) -> gr_not_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_not_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_not_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_check_topology(self, *args, **kwargs)

gr_not_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_ss_sptr_swigregister
gr_not_ss_sptr_swigregister(gr_not_ss_sptr)

gr_not_ss_sptr.block = lambda self: gr_not_ss_block (self)
gr_not_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def not_ss():
  """not_ss() -> gr_not_ss_sptr"""
  return _gnuradio_swig_py_gengen.not_ss()
class gr_or_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_or_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_or_bb_sptr
        __init__(self,  p) -> gr_or_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_or_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_or_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_check_topology(self, *args, **kwargs)

gr_or_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_bb_sptr_swigregister
gr_or_bb_sptr_swigregister(gr_or_bb_sptr)

gr_or_bb_sptr.block = lambda self: gr_or_bb_block (self)
gr_or_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def or_bb():
  """or_bb() -> gr_or_bb_sptr"""
  return _gnuradio_swig_py_gengen.or_bb()
class gr_or_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_or_ii)> 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_or_ii_sptr
        __init__(self,  p) -> gr_or_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_or_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_or_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_check_topology(self, *args, **kwargs)

gr_or_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_ii_sptr_swigregister
gr_or_ii_sptr_swigregister(gr_or_ii_sptr)

gr_or_ii_sptr.block = lambda self: gr_or_ii_block (self)
gr_or_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def or_ii():
  """or_ii() -> gr_or_ii_sptr"""
  return _gnuradio_swig_py_gengen.or_ii()
class gr_or_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_or_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_or_ss_sptr
        __init__(self,  p) -> gr_or_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_or_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_or_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_check_topology(self, *args, **kwargs)

gr_or_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_ss_sptr_swigregister
gr_or_ss_sptr_swigregister(gr_or_ss_sptr)

gr_or_ss_sptr.block = lambda self: gr_or_ss_block (self)
gr_or_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def or_ss():
  """or_ss() -> gr_or_ss_sptr"""
  return _gnuradio_swig_py_gengen.or_ss()
class gr_packed_to_unpacked_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_packed_to_unpacked_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_packed_to_unpacked_bb_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_packed_to_unpacked_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_packed_to_unpacked_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_check_topology(self, *args, **kwargs)

gr_packed_to_unpacked_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_swigregister
gr_packed_to_unpacked_bb_sptr_swigregister(gr_packed_to_unpacked_bb_sptr)

gr_packed_to_unpacked_bb_sptr.block = lambda self: gr_packed_to_unpacked_bb_block (self)
gr_packed_to_unpacked_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def packed_to_unpacked_bb(*args, **kwargs):
  """packed_to_unpacked_bb(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_packed_to_unpacked_bb_sptr"""
  return _gnuradio_swig_py_gengen.packed_to_unpacked_bb(*args, **kwargs)
class gr_packed_to_unpacked_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_packed_to_unpacked_ii)> 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_packed_to_unpacked_ii_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_packed_to_unpacked_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_packed_to_unpacked_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_check_topology(self, *args, **kwargs)

gr_packed_to_unpacked_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_swigregister
gr_packed_to_unpacked_ii_sptr_swigregister(gr_packed_to_unpacked_ii_sptr)

gr_packed_to_unpacked_ii_sptr.block = lambda self: gr_packed_to_unpacked_ii_block (self)
gr_packed_to_unpacked_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def packed_to_unpacked_ii(*args, **kwargs):
  """packed_to_unpacked_ii(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_packed_to_unpacked_ii_sptr"""
  return _gnuradio_swig_py_gengen.packed_to_unpacked_ii(*args, **kwargs)
class gr_packed_to_unpacked_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_packed_to_unpacked_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_packed_to_unpacked_ss_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_packed_to_unpacked_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_packed_to_unpacked_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_check_topology(self, *args, **kwargs)

gr_packed_to_unpacked_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_swigregister
gr_packed_to_unpacked_ss_sptr_swigregister(gr_packed_to_unpacked_ss_sptr)

gr_packed_to_unpacked_ss_sptr.block = lambda self: gr_packed_to_unpacked_ss_block (self)
gr_packed_to_unpacked_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def packed_to_unpacked_ss(*args, **kwargs):
  """packed_to_unpacked_ss(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_packed_to_unpacked_ss_sptr"""
  return _gnuradio_swig_py_gengen.packed_to_unpacked_ss(*args, **kwargs)
class gr_peak_detector_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_peak_detector_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_detector_fb_sptr
        __init__(self,  p) -> gr_peak_detector_fb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_peak_detector_fb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_peak_detector_fb_sptr
    __del__ = lambda self : None;
    def set_threshold_factor_rise(self, *args, **kwargs):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_threshold_factor_rise(self, *args, **kwargs)

    def set_threshold_factor_fall(self, *args, **kwargs):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_threshold_factor_fall(self, *args, **kwargs)

    def set_look_ahead(self, *args, **kwargs):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_look_ahead(self, *args, **kwargs)

    def set_alpha(self, *args, **kwargs):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_alpha(self, *args, **kwargs)

    def threshold_factor_rise(self):
        """threshold_factor_rise(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self):
        """threshold_factor_fall(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_threshold_factor_fall(self)

    def look_ahead(self):
        """look_ahead(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_look_ahead(self)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_alpha(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_check_topology(self, *args, **kwargs)

gr_peak_detector_fb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_swigregister
gr_peak_detector_fb_sptr_swigregister(gr_peak_detector_fb_sptr)

gr_peak_detector_fb_sptr.block = lambda self: gr_peak_detector_fb_block (self)
gr_peak_detector_fb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def peak_detector_fb(threshold_factor_rise = 0.25, threshold_factor_fall = 0.40, 
    look_ahead = 10, alpha = 0.001):
  """
    peak_detector_fb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10, float alpha = 0.001) -> gr_peak_detector_fb_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_fb(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)
class gr_peak_detector_ib_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_peak_detector_ib)> 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_detector_ib_sptr
        __init__(self,  p) -> gr_peak_detector_ib_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_peak_detector_ib_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_peak_detector_ib_sptr
    __del__ = lambda self : None;
    def set_threshold_factor_rise(self, *args, **kwargs):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_threshold_factor_rise(self, *args, **kwargs)

    def set_threshold_factor_fall(self, *args, **kwargs):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_threshold_factor_fall(self, *args, **kwargs)

    def set_look_ahead(self, *args, **kwargs):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_look_ahead(self, *args, **kwargs)

    def set_alpha(self, *args, **kwargs):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_alpha(self, *args, **kwargs)

    def threshold_factor_rise(self):
        """threshold_factor_rise(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self):
        """threshold_factor_fall(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_threshold_factor_fall(self)

    def look_ahead(self):
        """look_ahead(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_look_ahead(self)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_alpha(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_check_topology(self, *args, **kwargs)

gr_peak_detector_ib_sptr_swigregister = _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_swigregister
gr_peak_detector_ib_sptr_swigregister(gr_peak_detector_ib_sptr)

gr_peak_detector_ib_sptr.block = lambda self: gr_peak_detector_ib_block (self)
gr_peak_detector_ib_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def peak_detector_ib(threshold_factor_rise = 0.25, threshold_factor_fall = 0.40, 
    look_ahead = 10, alpha = 0.001):
  """
    peak_detector_ib(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10, float alpha = 0.001) -> gr_peak_detector_ib_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_ib(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)
class gr_peak_detector_sb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_peak_detector_sb)> 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_detector_sb_sptr
        __init__(self,  p) -> gr_peak_detector_sb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_peak_detector_sb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_peak_detector_sb_sptr
    __del__ = lambda self : None;
    def set_threshold_factor_rise(self, *args, **kwargs):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_threshold_factor_rise(self, *args, **kwargs)

    def set_threshold_factor_fall(self, *args, **kwargs):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_threshold_factor_fall(self, *args, **kwargs)

    def set_look_ahead(self, *args, **kwargs):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_look_ahead(self, *args, **kwargs)

    def set_alpha(self, *args, **kwargs):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_alpha(self, *args, **kwargs)

    def threshold_factor_rise(self):
        """threshold_factor_rise(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_threshold_factor_rise(self)

    def threshold_factor_fall(self):
        """threshold_factor_fall(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_threshold_factor_fall(self)

    def look_ahead(self):
        """look_ahead(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_look_ahead(self)

    def alpha(self):
        """alpha(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_alpha(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_check_topology(self, *args, **kwargs)

gr_peak_detector_sb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_swigregister
gr_peak_detector_sb_sptr_swigregister(gr_peak_detector_sb_sptr)

gr_peak_detector_sb_sptr.block = lambda self: gr_peak_detector_sb_block (self)
gr_peak_detector_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def peak_detector_sb(threshold_factor_rise = 0.25, threshold_factor_fall = 0.40, 
    look_ahead = 10, alpha = 0.001):
  """
    peak_detector_sb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10, float alpha = 0.001) -> gr_peak_detector_sb_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_sb(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)
class gr_sample_and_hold_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sample_and_hold_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_sample_and_hold_bb_sptr
        __init__(self,  p) -> gr_sample_and_hold_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sample_and_hold_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sample_and_hold_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_check_topology(self, *args, **kwargs)

gr_sample_and_hold_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_swigregister
gr_sample_and_hold_bb_sptr_swigregister(gr_sample_and_hold_bb_sptr)

gr_sample_and_hold_bb_sptr.block = lambda self: gr_sample_and_hold_bb_block (self)
gr_sample_and_hold_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sample_and_hold_bb():
  """sample_and_hold_bb() -> gr_sample_and_hold_bb_sptr"""
  return _gnuradio_swig_py_gengen.sample_and_hold_bb()
class gr_sample_and_hold_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sample_and_hold_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_sample_and_hold_ff_sptr
        __init__(self,  p) -> gr_sample_and_hold_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sample_and_hold_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sample_and_hold_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_check_topology(self, *args, **kwargs)

gr_sample_and_hold_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_swigregister
gr_sample_and_hold_ff_sptr_swigregister(gr_sample_and_hold_ff_sptr)

gr_sample_and_hold_ff_sptr.block = lambda self: gr_sample_and_hold_ff_block (self)
gr_sample_and_hold_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sample_and_hold_ff():
  """sample_and_hold_ff() -> gr_sample_and_hold_ff_sptr"""
  return _gnuradio_swig_py_gengen.sample_and_hold_ff()
class gr_sample_and_hold_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sample_and_hold_ii)> 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_sample_and_hold_ii_sptr
        __init__(self,  p) -> gr_sample_and_hold_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sample_and_hold_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sample_and_hold_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_check_topology(self, *args, **kwargs)

gr_sample_and_hold_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_swigregister
gr_sample_and_hold_ii_sptr_swigregister(gr_sample_and_hold_ii_sptr)

gr_sample_and_hold_ii_sptr.block = lambda self: gr_sample_and_hold_ii_block (self)
gr_sample_and_hold_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sample_and_hold_ii():
  """sample_and_hold_ii() -> gr_sample_and_hold_ii_sptr"""
  return _gnuradio_swig_py_gengen.sample_and_hold_ii()
class gr_sample_and_hold_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sample_and_hold_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_sample_and_hold_ss_sptr
        __init__(self,  p) -> gr_sample_and_hold_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sample_and_hold_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sample_and_hold_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_check_topology(self, *args, **kwargs)

gr_sample_and_hold_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_swigregister
gr_sample_and_hold_ss_sptr_swigregister(gr_sample_and_hold_ss_sptr)

gr_sample_and_hold_ss_sptr.block = lambda self: gr_sample_and_hold_ss_block (self)
gr_sample_and_hold_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sample_and_hold_ss():
  """sample_and_hold_ss() -> gr_sample_and_hold_ss_sptr"""
  return _gnuradio_swig_py_gengen.sample_and_hold_ss()
class gr_sig_source_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sig_source_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_sig_source_c_sptr
        __init__(self,  p) -> gr_sig_source_c_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sig_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sig_source_c_sptr
    __del__ = lambda self : None;
    def sampling_freq(self):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_sampling_freq(self)

    def waveform(self):
        """waveform(self) -> gr_waveform_t"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_waveform(self)

    def frequency(self):
        """frequency(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_frequency(self)

    def amplitude(self):
        """amplitude(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_amplitude(self)

    def offset(self):
        """offset(self) -> gr_complex"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_offset(self)

    def set_sampling_freq(self, *args, **kwargs):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_sampling_freq(self, *args, **kwargs)

    def set_waveform(self, *args, **kwargs):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_waveform(self, *args, **kwargs)

    def set_frequency(self, *args, **kwargs):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_frequency(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_amplitude(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """set_offset(self, gr_complex offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_offset(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_check_topology(self, *args, **kwargs)

gr_sig_source_c_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_swigregister
gr_sig_source_c_sptr_swigregister(gr_sig_source_c_sptr)

gr_sig_source_c_sptr.block = lambda self: gr_sig_source_c_block (self)
gr_sig_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sig_source_c(*args, **kwargs):
  """
    sig_source_c(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, gr_complex offset = 0) -> gr_sig_source_c_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_c(*args, **kwargs)
class gr_sig_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sig_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_sig_source_f_sptr
        __init__(self,  p) -> gr_sig_source_f_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sig_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sig_source_f_sptr
    __del__ = lambda self : None;
    def sampling_freq(self):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_sampling_freq(self)

    def waveform(self):
        """waveform(self) -> gr_waveform_t"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_waveform(self)

    def frequency(self):
        """frequency(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_frequency(self)

    def amplitude(self):
        """amplitude(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_amplitude(self)

    def offset(self):
        """offset(self) -> float"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_offset(self)

    def set_sampling_freq(self, *args, **kwargs):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_sampling_freq(self, *args, **kwargs)

    def set_waveform(self, *args, **kwargs):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_waveform(self, *args, **kwargs)

    def set_frequency(self, *args, **kwargs):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_frequency(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_amplitude(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """set_offset(self, float offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_offset(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_check_topology(self, *args, **kwargs)

gr_sig_source_f_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_swigregister
gr_sig_source_f_sptr_swigregister(gr_sig_source_f_sptr)

gr_sig_source_f_sptr.block = lambda self: gr_sig_source_f_block (self)
gr_sig_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sig_source_f(*args, **kwargs):
  """
    sig_source_f(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, float offset = 0) -> gr_sig_source_f_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_f(*args, **kwargs)
class gr_sig_source_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sig_source_i)> 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_sig_source_i_sptr
        __init__(self,  p) -> gr_sig_source_i_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sig_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sig_source_i_sptr
    __del__ = lambda self : None;
    def sampling_freq(self):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_sampling_freq(self)

    def waveform(self):
        """waveform(self) -> gr_waveform_t"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_waveform(self)

    def frequency(self):
        """frequency(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_frequency(self)

    def amplitude(self):
        """amplitude(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_amplitude(self)

    def offset(self):
        """offset(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_offset(self)

    def set_sampling_freq(self, *args, **kwargs):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_sampling_freq(self, *args, **kwargs)

    def set_waveform(self, *args, **kwargs):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_waveform(self, *args, **kwargs)

    def set_frequency(self, *args, **kwargs):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_frequency(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_amplitude(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """set_offset(self, int offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_offset(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_check_topology(self, *args, **kwargs)

gr_sig_source_i_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_swigregister
gr_sig_source_i_sptr_swigregister(gr_sig_source_i_sptr)

gr_sig_source_i_sptr.block = lambda self: gr_sig_source_i_block (self)
gr_sig_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sig_source_i(*args, **kwargs):
  """
    sig_source_i(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, int offset = 0) -> gr_sig_source_i_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_i(*args, **kwargs)
class gr_sig_source_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sig_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_sig_source_s_sptr
        __init__(self,  p) -> gr_sig_source_s_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sig_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sig_source_s_sptr
    __del__ = lambda self : None;
    def sampling_freq(self):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_sampling_freq(self)

    def waveform(self):
        """waveform(self) -> gr_waveform_t"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_waveform(self)

    def frequency(self):
        """frequency(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_frequency(self)

    def amplitude(self):
        """amplitude(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_amplitude(self)

    def offset(self):
        """offset(self) -> short"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_offset(self)

    def set_sampling_freq(self, *args, **kwargs):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_sampling_freq(self, *args, **kwargs)

    def set_waveform(self, *args, **kwargs):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_waveform(self, *args, **kwargs)

    def set_frequency(self, *args, **kwargs):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_frequency(self, *args, **kwargs)

    def set_amplitude(self, *args, **kwargs):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_amplitude(self, *args, **kwargs)

    def set_offset(self, *args, **kwargs):
        """set_offset(self, short offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_offset(self, *args, **kwargs)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_check_topology(self, *args, **kwargs)

gr_sig_source_s_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_swigregister
gr_sig_source_s_sptr_swigregister(gr_sig_source_s_sptr)

gr_sig_source_s_sptr.block = lambda self: gr_sig_source_s_block (self)
gr_sig_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sig_source_s(*args, **kwargs):
  """
    sig_source_s(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, short offset = 0) -> gr_sig_source_s_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_s(*args, **kwargs)
class gr_sub_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sub_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_sub_cc_sptr
        __init__(self,  p) -> gr_sub_cc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sub_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sub_cc_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_check_topology(self, *args, **kwargs)

gr_sub_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_cc_sptr_swigregister
gr_sub_cc_sptr_swigregister(gr_sub_cc_sptr)

gr_sub_cc_sptr.block = lambda self: gr_sub_cc_block (self)
gr_sub_cc_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sub_cc(vlen = 1):
  """sub_cc(size_t vlen = 1) -> gr_sub_cc_sptr"""
  return _gnuradio_swig_py_gengen.sub_cc(vlen)
class gr_sub_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sub_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_sub_ff_sptr
        __init__(self,  p) -> gr_sub_ff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sub_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sub_ff_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_check_topology(self, *args, **kwargs)

gr_sub_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ff_sptr_swigregister
gr_sub_ff_sptr_swigregister(gr_sub_ff_sptr)

gr_sub_ff_sptr.block = lambda self: gr_sub_ff_block (self)
gr_sub_ff_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sub_ff(vlen = 1):
  """sub_ff(size_t vlen = 1) -> gr_sub_ff_sptr"""
  return _gnuradio_swig_py_gengen.sub_ff(vlen)
class gr_sub_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sub_ii)> 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_sub_ii_sptr
        __init__(self,  p) -> gr_sub_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sub_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sub_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_check_topology(self, *args, **kwargs)

gr_sub_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ii_sptr_swigregister
gr_sub_ii_sptr_swigregister(gr_sub_ii_sptr)

gr_sub_ii_sptr.block = lambda self: gr_sub_ii_block (self)
gr_sub_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sub_ii(vlen = 1):
  """sub_ii(size_t vlen = 1) -> gr_sub_ii_sptr"""
  return _gnuradio_swig_py_gengen.sub_ii(vlen)
class gr_sub_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_sub_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_sub_ss_sptr
        __init__(self,  p) -> gr_sub_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_sub_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_sub_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_check_topology(self, *args, **kwargs)

gr_sub_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ss_sptr_swigregister
gr_sub_ss_sptr_swigregister(gr_sub_ss_sptr)

gr_sub_ss_sptr.block = lambda self: gr_sub_ss_block (self)
gr_sub_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def sub_ss(vlen = 1):
  """sub_ss(size_t vlen = 1) -> gr_sub_ss_sptr"""
  return _gnuradio_swig_py_gengen.sub_ss(vlen)
class gr_unpacked_to_packed_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_unpacked_to_packed_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_unpacked_to_packed_bb_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_unpacked_to_packed_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_unpacked_to_packed_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_check_topology(self, *args, **kwargs)

gr_unpacked_to_packed_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_swigregister
gr_unpacked_to_packed_bb_sptr_swigregister(gr_unpacked_to_packed_bb_sptr)

gr_unpacked_to_packed_bb_sptr.block = lambda self: gr_unpacked_to_packed_bb_block (self)
gr_unpacked_to_packed_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def unpacked_to_packed_bb(*args, **kwargs):
  """unpacked_to_packed_bb(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_unpacked_to_packed_bb_sptr"""
  return _gnuradio_swig_py_gengen.unpacked_to_packed_bb(*args, **kwargs)
class gr_unpacked_to_packed_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_unpacked_to_packed_ii)> 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_unpacked_to_packed_ii_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_unpacked_to_packed_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_unpacked_to_packed_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_check_topology(self, *args, **kwargs)

gr_unpacked_to_packed_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_swigregister
gr_unpacked_to_packed_ii_sptr_swigregister(gr_unpacked_to_packed_ii_sptr)

gr_unpacked_to_packed_ii_sptr.block = lambda self: gr_unpacked_to_packed_ii_block (self)
gr_unpacked_to_packed_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def unpacked_to_packed_ii(*args, **kwargs):
  """unpacked_to_packed_ii(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_unpacked_to_packed_ii_sptr"""
  return _gnuradio_swig_py_gengen.unpacked_to_packed_ii(*args, **kwargs)
class gr_unpacked_to_packed_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_unpacked_to_packed_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_unpacked_to_packed_ss_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_unpacked_to_packed_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_unpacked_to_packed_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_check_topology(self, *args, **kwargs)

gr_unpacked_to_packed_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_swigregister
gr_unpacked_to_packed_ss_sptr_swigregister(gr_unpacked_to_packed_ss_sptr)

gr_unpacked_to_packed_ss_sptr.block = lambda self: gr_unpacked_to_packed_ss_block (self)
gr_unpacked_to_packed_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def unpacked_to_packed_ss(*args, **kwargs):
  """unpacked_to_packed_ss(unsigned int bits_per_chunk, gr_endianness_t endianness) -> gr_unpacked_to_packed_ss_sptr"""
  return _gnuradio_swig_py_gengen.unpacked_to_packed_ss(*args, **kwargs)
class gr_vector_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_sink_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_vector_sink_b_sptr
        __init__(self,  p) -> gr_vector_sink_b_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_sink_b_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_sink_b_sptr
    __del__ = lambda self : None;
    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_clear(self)

    def data(self):
        """data(self) -> __dummy_0__"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_data(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_check_topology(self, *args, **kwargs)

gr_vector_sink_b_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_swigregister
gr_vector_sink_b_sptr_swigregister(gr_vector_sink_b_sptr)

gr_vector_sink_b_sptr.block = lambda self: gr_vector_sink_b_block (self)
gr_vector_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_sink_b(vlen = 1):
  """vector_sink_b(int vlen = 1) -> gr_vector_sink_b_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_b(vlen)
class gr_vector_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_sink_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_vector_sink_c_sptr
        __init__(self,  p) -> gr_vector_sink_c_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_sink_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_sink_c_sptr
    __del__ = lambda self : None;
    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_clear(self)

    def data(self):
        """data(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_data(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_check_topology(self, *args, **kwargs)

gr_vector_sink_c_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_swigregister
gr_vector_sink_c_sptr_swigregister(gr_vector_sink_c_sptr)

gr_vector_sink_c_sptr.block = lambda self: gr_vector_sink_c_block (self)
gr_vector_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_sink_c(vlen = 1):
  """vector_sink_c(int vlen = 1) -> gr_vector_sink_c_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_c(vlen)
class gr_vector_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_sink_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_vector_sink_f_sptr
        __init__(self,  p) -> gr_vector_sink_f_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_sink_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_sink_f_sptr
    __del__ = lambda self : None;
    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_clear(self)

    def data(self):
        """data(self) -> __dummy_4__"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_data(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_check_topology(self, *args, **kwargs)

gr_vector_sink_f_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_swigregister
gr_vector_sink_f_sptr_swigregister(gr_vector_sink_f_sptr)

gr_vector_sink_f_sptr.block = lambda self: gr_vector_sink_f_block (self)
gr_vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_sink_f(vlen = 1):
  """vector_sink_f(int vlen = 1) -> gr_vector_sink_f_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_f(vlen)
class gr_vector_sink_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_sink_i)> 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_sink_i_sptr
        __init__(self,  p) -> gr_vector_sink_i_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_sink_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_sink_i_sptr
    __del__ = lambda self : None;
    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_clear(self)

    def data(self):
        """data(self) -> __dummy_3__"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_data(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_check_topology(self, *args, **kwargs)

gr_vector_sink_i_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_swigregister
gr_vector_sink_i_sptr_swigregister(gr_vector_sink_i_sptr)

gr_vector_sink_i_sptr.block = lambda self: gr_vector_sink_i_block (self)
gr_vector_sink_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_sink_i(vlen = 1):
  """vector_sink_i(int vlen = 1) -> gr_vector_sink_i_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_i(vlen)
class gr_vector_sink_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_sink_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_vector_sink_s_sptr
        __init__(self,  p) -> gr_vector_sink_s_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_sink_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_sink_s_sptr
    __del__ = lambda self : None;
    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_clear(self)

    def data(self):
        """data(self) -> __dummy_2__"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_data(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_check_topology(self, *args, **kwargs)

gr_vector_sink_s_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_swigregister
gr_vector_sink_s_sptr_swigregister(gr_vector_sink_s_sptr)

gr_vector_sink_s_sptr.block = lambda self: gr_vector_sink_s_block (self)
gr_vector_sink_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_sink_s(vlen = 1):
  """vector_sink_s(int vlen = 1) -> gr_vector_sink_s_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_s(vlen)
class gr_vector_source_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_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_vector_source_b_sptr
        __init__(self,  p) -> gr_vector_source_b_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_source_b_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_source_b_sptr
    __del__ = lambda self : None;
    def rewind(self):
        """rewind(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_rewind(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_check_topology(self, *args, **kwargs)

gr_vector_source_b_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_swigregister
gr_vector_source_b_sptr_swigregister(gr_vector_source_b_sptr)

gr_vector_source_b_sptr.block = lambda self: gr_vector_source_b_block (self)
gr_vector_source_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_source_b(*args, **kwargs):
  """vector_source_b(__dummy_0__ data, bool repeat = False, int vlen = 1) -> gr_vector_source_b_sptr"""
  return _gnuradio_swig_py_gengen.vector_source_b(*args, **kwargs)
class gr_vector_source_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_source_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_vector_source_c_sptr
        __init__(self,  p) -> gr_vector_source_c_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_source_c_sptr
    __del__ = lambda self : None;
    def rewind(self):
        """rewind(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_rewind(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_check_topology(self, *args, **kwargs)

gr_vector_source_c_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_swigregister
gr_vector_source_c_sptr_swigregister(gr_vector_source_c_sptr)

gr_vector_source_c_sptr.block = lambda self: gr_vector_source_c_block (self)
gr_vector_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_source_c(*args, **kwargs):
  """
    vector_source_c(std::vector<(gr_complex,std::allocator<(gr_complex)>)> data, 
        bool repeat = False, int vlen = 1) -> gr_vector_source_c_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_c(*args, **kwargs)
class gr_vector_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_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_vector_source_f_sptr
        __init__(self,  p) -> gr_vector_source_f_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_source_f_sptr
    __del__ = lambda self : None;
    def rewind(self):
        """rewind(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_rewind(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_check_topology(self, *args, **kwargs)

gr_vector_source_f_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_swigregister
gr_vector_source_f_sptr_swigregister(gr_vector_source_f_sptr)

gr_vector_source_f_sptr.block = lambda self: gr_vector_source_f_block (self)
gr_vector_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_source_f(*args, **kwargs):
  """vector_source_f(__dummy_4__ data, bool repeat = False, int vlen = 1) -> gr_vector_source_f_sptr"""
  return _gnuradio_swig_py_gengen.vector_source_f(*args, **kwargs)
class gr_vector_source_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_source_i)> 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_source_i_sptr
        __init__(self,  p) -> gr_vector_source_i_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_source_i_sptr
    __del__ = lambda self : None;
    def rewind(self):
        """rewind(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_rewind(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_check_topology(self, *args, **kwargs)

gr_vector_source_i_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_swigregister
gr_vector_source_i_sptr_swigregister(gr_vector_source_i_sptr)

gr_vector_source_i_sptr.block = lambda self: gr_vector_source_i_block (self)
gr_vector_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_source_i(*args, **kwargs):
  """vector_source_i(__dummy_3__ data, bool repeat = False, int vlen = 1) -> gr_vector_source_i_sptr"""
  return _gnuradio_swig_py_gengen.vector_source_i(*args, **kwargs)
class gr_vector_source_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_vector_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_vector_source_s_sptr
        __init__(self,  p) -> gr_vector_source_s_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_vector_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_vector_source_s_sptr
    __del__ = lambda self : None;
    def rewind(self):
        """rewind(self)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_rewind(self)

    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_check_topology(self, *args, **kwargs)

gr_vector_source_s_sptr_swigregister = _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_swigregister
gr_vector_source_s_sptr_swigregister(gr_vector_source_s_sptr)

gr_vector_source_s_sptr.block = lambda self: gr_vector_source_s_block (self)
gr_vector_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def vector_source_s(*args, **kwargs):
  """vector_source_s(__dummy_2__ data, bool repeat = False, int vlen = 1) -> gr_vector_source_s_sptr"""
  return _gnuradio_swig_py_gengen.vector_source_s(*args, **kwargs)
class gr_xor_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_xor_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_xor_bb_sptr
        __init__(self,  p) -> gr_xor_bb_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_xor_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_xor_bb_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_check_topology(self, *args, **kwargs)

gr_xor_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_bb_sptr_swigregister
gr_xor_bb_sptr_swigregister(gr_xor_bb_sptr)

gr_xor_bb_sptr.block = lambda self: gr_xor_bb_block (self)
gr_xor_bb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def xor_bb():
  """xor_bb() -> gr_xor_bb_sptr"""
  return _gnuradio_swig_py_gengen.xor_bb()
class gr_xor_ii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_xor_ii)> 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_xor_ii_sptr
        __init__(self,  p) -> gr_xor_ii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_xor_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_xor_ii_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_check_topology(self, *args, **kwargs)

gr_xor_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_ii_sptr_swigregister
gr_xor_ii_sptr_swigregister(gr_xor_ii_sptr)

gr_xor_ii_sptr.block = lambda self: gr_xor_ii_block (self)
gr_xor_ii_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def xor_ii():
  """xor_ii() -> gr_xor_ii_sptr"""
  return _gnuradio_swig_py_gengen.xor_ii()
class gr_xor_ss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_xor_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_xor_ss_sptr
        __init__(self,  p) -> gr_xor_ss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_xor_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_gengen.delete_gr_xor_ss_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_detail(self)

    def set_detail(self, *args, **kwargs):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_set_detail(self, *args, **kwargs)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_check_topology(self, *args, **kwargs)

gr_xor_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_ss_sptr_swigregister
gr_xor_ss_sptr_swigregister(gr_xor_ss_sptr)

gr_xor_ss_sptr.block = lambda self: gr_xor_ss_block (self)
gr_xor_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())


def xor_ss():
  """xor_ss() -> gr_xor_ss_sptr"""
  return _gnuradio_swig_py_gengen.xor_ss()


