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

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gnuradio_swig_py_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


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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_cc_sptr_check_topology(self, *args)

gr_add_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_cc_sptr_swigregister
gr_add_cc_sptr_swigregister(gr_add_cc_sptr)


def gr_add_cc_block(*args):
  """gr_add_cc_block(gr_add_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_cc_block(*args)
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():
  """add_cc() -> gr_add_cc_sptr"""
  return _gnuradio_swig_py_gengen.add_cc()
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):
        """set_k(self, gr_complex k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_cc_sptr_check_topology(self, *args)

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)


def gr_add_const_cc_block(*args):
  """gr_add_const_cc_block(gr_add_const_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_cc_block(*args)
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):
  """add_const_cc(gr_complex k) -> gr_add_const_cc_sptr"""
  return _gnuradio_swig_py_gengen.add_const_cc(*args)
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):
        """set_k(self, float k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ff_sptr_check_topology(self, *args)

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)


def gr_add_const_ff_block(*args):
  """gr_add_const_ff_block(gr_add_const_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_ff_block(*args)
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):
  """add_const_ff(float k) -> gr_add_const_ff_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ff(*args)
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):
        """set_k(self, int k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ii_sptr_check_topology(self, *args)

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)


def gr_add_const_ii_block(*args):
  """gr_add_const_ii_block(gr_add_const_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_ii_block(*args)
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):
  """add_const_ii(int k) -> gr_add_const_ii_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ii(*args)
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):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_sf_sptr_check_topology(self, *args)

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)


def gr_add_const_sf_block(*args):
  """gr_add_const_sf_block(gr_add_const_sf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_sf_block(*args)
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):
  """add_const_sf(short k) -> gr_add_const_sf_sptr"""
  return _gnuradio_swig_py_gengen.add_const_sf(*args)
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):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_ss_sptr_check_topology(self, *args)

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)


def gr_add_const_ss_block(*args):
  """gr_add_const_ss_block(gr_add_const_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_ss_block(*args)
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):
  """add_const_ss(short k) -> gr_add_const_ss_sptr"""
  return _gnuradio_swig_py_gengen.add_const_ss(*args)
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):
        """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)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vcc_sptr_check_topology(self, *args)

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)


def gr_add_const_vcc_block(*args):
  """gr_add_const_vcc_block(gr_add_const_vcc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_vcc_block(*args)
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):
  """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)
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):
        """set_k(self, __dummy_4__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vff_sptr_check_topology(self, *args)

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)


def gr_add_const_vff_block(*args):
  """gr_add_const_vff_block(gr_add_const_vff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_vff_block(*args)
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):
  """add_const_vff(__dummy_4__ k) -> gr_add_const_vff_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vff(*args)
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):
        """set_k(self, __dummy_3__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vii_sptr_check_topology(self, *args)

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)


def gr_add_const_vii_block(*args):
  """gr_add_const_vii_block(gr_add_const_vii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_vii_block(*args)
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):
  """add_const_vii(__dummy_3__ k) -> gr_add_const_vii_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vii(*args)
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):
        """set_k(self, __dummy_2__ k)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_const_vss_sptr_check_topology(self, *args)

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)


def gr_add_const_vss_block(*args):
  """gr_add_const_vss_block(gr_add_const_vss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_const_vss_block(*args)
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):
  """add_const_vss(__dummy_2__ k) -> gr_add_const_vss_sptr"""
  return _gnuradio_swig_py_gengen.add_const_vss(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ff_sptr_check_topology(self, *args)

gr_add_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ff_sptr_swigregister
gr_add_ff_sptr_swigregister(gr_add_ff_sptr)


def gr_add_ff_block(*args):
  """gr_add_ff_block(gr_add_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_ff_block(*args)
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():
  """add_ff() -> gr_add_ff_sptr"""
  return _gnuradio_swig_py_gengen.add_ff()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ii_sptr_check_topology(self, *args)

gr_add_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ii_sptr_swigregister
gr_add_ii_sptr_swigregister(gr_add_ii_sptr)


def gr_add_ii_block(*args):
  """gr_add_ii_block(gr_add_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_ii_block(*args)
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():
  """add_ii() -> gr_add_ii_sptr"""
  return _gnuradio_swig_py_gengen.add_ii()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_add_ss_sptr_check_topology(self, *args)

gr_add_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_ss_sptr_swigregister
gr_add_ss_sptr_swigregister(gr_add_ss_sptr)


def gr_add_ss_block(*args):
  """gr_add_ss_block(gr_add_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_add_ss_block(*args)
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():
  """add_ss() -> gr_add_ss_sptr"""
  return _gnuradio_swig_py_gengen.add_ss()
class gr_add_vcc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_vcc_sptr
        __init__(self,  p) -> gr_add_vcc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_vcc_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_add_vcc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_vcc_sptr_swigregister
gr_add_vcc_sptr_swigregister(gr_add_vcc_sptr)


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


def add_vcc(*args):
  """add_vcc(size_t nitems_per_block) -> gr_add_vcc_sptr"""
  return _gnuradio_swig_py_gengen.add_vcc(*args)
class gr_add_vff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_vff_sptr
        __init__(self,  p) -> gr_add_vff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_vff_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_add_vff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_vff_sptr_swigregister
gr_add_vff_sptr_swigregister(gr_add_vff_sptr)


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


def add_vff(*args):
  """add_vff(size_t nitems_per_block) -> gr_add_vff_sptr"""
  return _gnuradio_swig_py_gengen.add_vff(*args)
class gr_add_vii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_vii_sptr
        __init__(self,  p) -> gr_add_vii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_vii_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_add_vii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_vii_sptr_swigregister
gr_add_vii_sptr_swigregister(gr_add_vii_sptr)


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


def add_vii(*args):
  """add_vii(size_t nitems_per_block) -> gr_add_vii_sptr"""
  return _gnuradio_swig_py_gengen.add_vii(*args)
class gr_add_vss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_add_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_vss_sptr
        __init__(self,  p) -> gr_add_vss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_add_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_add_vss_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_add_vss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_add_vss_sptr_swigregister
gr_add_vss_sptr_swigregister(gr_add_vss_sptr)


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


def add_vss(*args):
  """add_vss(size_t nitems_per_block) -> gr_add_vss_sptr"""
  return _gnuradio_swig_py_gengen.add_vss(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_bb_sptr_check_topology(self, *args)

gr_and_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_bb_sptr_swigregister
gr_and_bb_sptr_swigregister(gr_and_bb_sptr)


def gr_and_bb_block(*args):
  """gr_and_bb_block(gr_and_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_and_bb_block(*args)
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_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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ii_sptr_check_topology(self, *args)

gr_and_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_ii_sptr_swigregister
gr_and_ii_sptr_swigregister(gr_and_ii_sptr)


def gr_and_ii_block(*args):
  """gr_and_ii_block(gr_and_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_and_ii_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_and_ss_sptr_check_topology(self, *args)

gr_and_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_and_ss_sptr_swigregister
gr_and_ss_sptr_swigregister(gr_and_ss_sptr)


def gr_and_ss_block(*args):
  """gr_and_ss_block(gr_and_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_and_ss_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_check_topology(self, *args)

gr_argmax_fs_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_fs_sptr_swigregister
gr_argmax_fs_sptr_swigregister(gr_argmax_fs_sptr)


def gr_argmax_fs_block(*args):
  """gr_argmax_fs_block(gr_argmax_fs_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_argmax_fs_block(*args)
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):
  """argmax_fs(size_t vlen) -> gr_argmax_fs_sptr"""
  return _gnuradio_swig_py_gengen.argmax_fs(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_is_sptr_check_topology(self, *args)

gr_argmax_is_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_is_sptr_swigregister
gr_argmax_is_sptr_swigregister(gr_argmax_is_sptr)


def gr_argmax_is_block(*args):
  """gr_argmax_is_block(gr_argmax_is_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_argmax_is_block(*args)
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):
  """argmax_is(size_t vlen) -> gr_argmax_is_sptr"""
  return _gnuradio_swig_py_gengen.argmax_is(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_check_topology(self, *args)

gr_argmax_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_argmax_ss_sptr_swigregister
gr_argmax_ss_sptr_swigregister(gr_argmax_ss_sptr)


def gr_argmax_ss_block(*args):
  """gr_argmax_ss_block(gr_argmax_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_argmax_ss_block(*args)
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):
  """argmax_ss(size_t vlen) -> gr_argmax_ss_sptr"""
  return _gnuradio_swig_py_gengen.argmax_ss(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_sptr_check_topology(self, *args)

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)


def gr_chunks_to_symbols_bc_block(*args):
  """gr_chunks_to_symbols_bc_block(gr_chunks_to_symbols_bc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bc_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_sptr_check_topology(self, *args)

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)

def chunks_to_symbols_bc(*args):
  """
    chunks_to_symbols_bc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_bc_sptr
    chunks_to_symbols_bc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table) -> gr_chunks_to_symbols_bc_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_bc(*args)


def gr_chunks_to_symbols_bf_block(*args):
  """gr_chunks_to_symbols_bf_block(gr_chunks_to_symbols_bf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_bf_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_sptr_check_topology(self, *args)

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)

def chunks_to_symbols_bf(*args):
  """
    chunks_to_symbols_bf(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_bf_sptr
    chunks_to_symbols_bf(__dummy_4__ symbol_table) -> gr_chunks_to_symbols_bf_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_bf(*args)


def gr_chunks_to_symbols_ic_block(*args):
  """gr_chunks_to_symbols_ic_block(gr_chunks_to_symbols_ic_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_ic_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_sptr_check_topology(self, *args)

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)

def chunks_to_symbols_ic(*args):
  """
    chunks_to_symbols_ic(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_ic_sptr
    chunks_to_symbols_ic(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table) -> gr_chunks_to_symbols_ic_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_ic(*args)


def gr_chunks_to_symbols_if_block(*args):
  """gr_chunks_to_symbols_if_block(gr_chunks_to_symbols_if_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_if_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_sptr_check_topology(self, *args)

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)

def chunks_to_symbols_if(*args):
  """
    chunks_to_symbols_if(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_if_sptr
    chunks_to_symbols_if(__dummy_4__ symbol_table) -> gr_chunks_to_symbols_if_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_if(*args)


def gr_chunks_to_symbols_sc_block(*args):
  """gr_chunks_to_symbols_sc_block(gr_chunks_to_symbols_sc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sc_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_sptr_check_topology(self, *args)

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)

def chunks_to_symbols_sc(*args):
  """
    chunks_to_symbols_sc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table, 
        int D = 1) -> gr_chunks_to_symbols_sc_sptr
    chunks_to_symbols_sc(std::vector<(gr_complex,std::allocator<(gr_complex)>)> symbol_table) -> gr_chunks_to_symbols_sc_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_sc(*args)


def gr_chunks_to_symbols_sf_block(*args):
  """gr_chunks_to_symbols_sf_block(gr_chunks_to_symbols_sf_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_chunks_to_symbols_sf_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_cc_sptr_check_topology(self, *args)

gr_divide_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_cc_sptr_swigregister
gr_divide_cc_sptr_swigregister(gr_divide_cc_sptr)

def chunks_to_symbols_sf(*args):
  """
    chunks_to_symbols_sf(__dummy_4__ symbol_table, int D = 1) -> gr_chunks_to_symbols_sf_sptr
    chunks_to_symbols_sf(__dummy_4__ symbol_table) -> gr_chunks_to_symbols_sf_sptr
    """
  return _gnuradio_swig_py_gengen.chunks_to_symbols_sf(*args)


def gr_divide_cc_block(*args):
  """gr_divide_cc_block(gr_divide_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_divide_cc_block(*args)
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():
  """divide_cc() -> gr_divide_cc_sptr"""
  return _gnuradio_swig_py_gengen.divide_cc()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ff_sptr_check_topology(self, *args)

gr_divide_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ff_sptr_swigregister
gr_divide_ff_sptr_swigregister(gr_divide_ff_sptr)


def gr_divide_ff_block(*args):
  """gr_divide_ff_block(gr_divide_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_divide_ff_block(*args)
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():
  """divide_ff() -> gr_divide_ff_sptr"""
  return _gnuradio_swig_py_gengen.divide_ff()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ii_sptr_check_topology(self, *args)

gr_divide_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ii_sptr_swigregister
gr_divide_ii_sptr_swigregister(gr_divide_ii_sptr)


def gr_divide_ii_block(*args):
  """gr_divide_ii_block(gr_divide_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_divide_ii_block(*args)
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():
  """divide_ii() -> gr_divide_ii_sptr"""
  return _gnuradio_swig_py_gengen.divide_ii()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_divide_ss_sptr_check_topology(self, *args)

gr_divide_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_divide_ss_sptr_swigregister
gr_divide_ss_sptr_swigregister(gr_divide_ss_sptr)


def gr_divide_ss_block(*args):
  """gr_divide_ss_block(gr_divide_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_divide_ss_block(*args)
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():
  """divide_ss() -> gr_divide_ss_sptr"""
  return _gnuradio_swig_py_gengen.divide_ss()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_check_topology(self, *args)

gr_integrate_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_cc_sptr_swigregister
gr_integrate_cc_sptr_swigregister(gr_integrate_cc_sptr)


def gr_integrate_cc_block(*args):
  """gr_integrate_cc_block(gr_integrate_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_integrate_cc_block(*args)
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):
  """integrate_cc(int decim) -> gr_integrate_cc_sptr"""
  return _gnuradio_swig_py_gengen.integrate_cc(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_check_topology(self, *args)

gr_integrate_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ff_sptr_swigregister
gr_integrate_ff_sptr_swigregister(gr_integrate_ff_sptr)


def gr_integrate_ff_block(*args):
  """gr_integrate_ff_block(gr_integrate_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_integrate_ff_block(*args)
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):
  """integrate_ff(int decim) -> gr_integrate_ff_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ff(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_check_topology(self, *args)

gr_integrate_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ii_sptr_swigregister
gr_integrate_ii_sptr_swigregister(gr_integrate_ii_sptr)


def gr_integrate_ii_block(*args):
  """gr_integrate_ii_block(gr_integrate_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_integrate_ii_block(*args)
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):
  """integrate_ii(int decim) -> gr_integrate_ii_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ii(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_check_topology(self, *args)

gr_integrate_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_integrate_ss_sptr_swigregister
gr_integrate_ss_sptr_swigregister(gr_integrate_ss_sptr)


def gr_integrate_ss_block(*args):
  """gr_integrate_ss_block(gr_integrate_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_integrate_ss_block(*args)
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):
  """integrate_ss(int decim) -> gr_integrate_ss_sptr"""
  return _gnuradio_swig_py_gengen.integrate_ss(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ff_sptr_check_topology(self, *args)

gr_max_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ff_sptr_swigregister
gr_max_ff_sptr_swigregister(gr_max_ff_sptr)


def gr_max_ff_block(*args):
  """gr_max_ff_block(gr_max_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_max_ff_block(*args)
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):
  """max_ff(size_t vlen) -> gr_max_ff_sptr"""
  return _gnuradio_swig_py_gengen.max_ff(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ii_sptr_check_topology(self, *args)

gr_max_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ii_sptr_swigregister
gr_max_ii_sptr_swigregister(gr_max_ii_sptr)


def gr_max_ii_block(*args):
  """gr_max_ii_block(gr_max_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_max_ii_block(*args)
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):
  """max_ii(size_t vlen) -> gr_max_ii_sptr"""
  return _gnuradio_swig_py_gengen.max_ii(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_max_ss_sptr_check_topology(self, *args)

gr_max_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_max_ss_sptr_swigregister
gr_max_ss_sptr_swigregister(gr_max_ss_sptr)


def gr_max_ss_block(*args):
  """gr_max_ss_block(gr_max_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_max_ss_block(*args)
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):
  """max_ss(size_t vlen) -> gr_max_ss_sptr"""
  return _gnuradio_swig_py_gengen.max_ss(*args)
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_cc_sptr_check_topology(self, *args)

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)


def gr_moving_average_cc_block(*args):
  """gr_moving_average_cc_block(gr_moving_average_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_moving_average_cc_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ff_sptr_check_topology(self, *args)

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)

def moving_average_cc(*args):
  """
    moving_average_cc(int length, gr_complex scale, int max_iter = 4096) -> gr_moving_average_cc_sptr
    moving_average_cc(int length, gr_complex scale) -> gr_moving_average_cc_sptr
    """
  return _gnuradio_swig_py_gengen.moving_average_cc(*args)


def gr_moving_average_ff_block(*args):
  """gr_moving_average_ff_block(gr_moving_average_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_moving_average_ff_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ii_sptr_check_topology(self, *args)

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)

def moving_average_ff(*args):
  """
    moving_average_ff(int length, float scale, int max_iter = 4096) -> gr_moving_average_ff_sptr
    moving_average_ff(int length, float scale) -> gr_moving_average_ff_sptr
    """
  return _gnuradio_swig_py_gengen.moving_average_ff(*args)


def gr_moving_average_ii_block(*args):
  """gr_moving_average_ii_block(gr_moving_average_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_moving_average_ii_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_moving_average_ss_sptr_check_topology(self, *args)

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)

def moving_average_ii(*args):
  """
    moving_average_ii(int length, int scale, int max_iter = 4096) -> gr_moving_average_ii_sptr
    moving_average_ii(int length, int scale) -> gr_moving_average_ii_sptr
    """
  return _gnuradio_swig_py_gengen.moving_average_ii(*args)


def gr_moving_average_ss_block(*args):
  """gr_moving_average_ss_block(gr_moving_average_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_moving_average_ss_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_check_topology(self, *args)

gr_multiply_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_cc_sptr_swigregister
gr_multiply_cc_sptr_swigregister(gr_multiply_cc_sptr)

def moving_average_ss(*args):
  """
    moving_average_ss(int length, short scale, int max_iter = 4096) -> gr_moving_average_ss_sptr
    moving_average_ss(int length, short scale) -> gr_moving_average_ss_sptr
    """
  return _gnuradio_swig_py_gengen.moving_average_ss(*args)


def gr_multiply_cc_block(*args):
  """gr_multiply_cc_block(gr_multiply_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_cc_block(*args)
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():
  """multiply_cc() -> gr_multiply_cc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_cc()
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):
        """set_k(self, gr_complex k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_cc_sptr_check_topology(self, *args)

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)


def gr_multiply_const_cc_block(*args):
  """gr_multiply_const_cc_block(gr_multiply_const_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_cc_block(*args)
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):
  """multiply_const_cc(gr_complex k) -> gr_multiply_const_cc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_cc(*args)
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):
        """set_k(self, float k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ff_sptr_check_topology(self, *args)

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)


def gr_multiply_const_ff_block(*args):
  """gr_multiply_const_ff_block(gr_multiply_const_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_ff_block(*args)
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):
  """multiply_const_ff(float k) -> gr_multiply_const_ff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ff(*args)
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):
        """set_k(self, int k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ii_sptr_check_topology(self, *args)

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)


def gr_multiply_const_ii_block(*args):
  """gr_multiply_const_ii_block(gr_multiply_const_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_ii_block(*args)
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):
  """multiply_const_ii(int k) -> gr_multiply_const_ii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ii(*args)
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):
        """set_k(self, short k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_ss_sptr_check_topology(self, *args)

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)


def gr_multiply_const_ss_block(*args):
  """gr_multiply_const_ss_block(gr_multiply_const_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_ss_block(*args)
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):
  """multiply_const_ss(short k) -> gr_multiply_const_ss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_ss(*args)
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):
        """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)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_sptr_check_topology(self, *args)

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)


def gr_multiply_const_vcc_block(*args):
  """gr_multiply_const_vcc_block(gr_multiply_const_vcc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_vcc_block(*args)
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):
  """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)
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):
        """set_k(self, __dummy_4__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vff_sptr_check_topology(self, *args)

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)


def gr_multiply_const_vff_block(*args):
  """gr_multiply_const_vff_block(gr_multiply_const_vff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_vff_block(*args)
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):
  """multiply_const_vff(__dummy_4__ k) -> gr_multiply_const_vff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vff(*args)
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):
        """set_k(self, __dummy_3__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vii_sptr_check_topology(self, *args)

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)


def gr_multiply_const_vii_block(*args):
  """gr_multiply_const_vii_block(gr_multiply_const_vii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_vii_block(*args)
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):
  """multiply_const_vii(__dummy_3__ k) -> gr_multiply_const_vii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vii(*args)
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):
        """set_k(self, __dummy_2__ k)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_set_k(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_const_vss_sptr_check_topology(self, *args)

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)


def gr_multiply_const_vss_block(*args):
  """gr_multiply_const_vss_block(gr_multiply_const_vss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_const_vss_block(*args)
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):
  """multiply_const_vss(__dummy_2__ k) -> gr_multiply_const_vss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_const_vss(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_check_topology(self, *args)

gr_multiply_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ff_sptr_swigregister
gr_multiply_ff_sptr_swigregister(gr_multiply_ff_sptr)


def gr_multiply_ff_block(*args):
  """gr_multiply_ff_block(gr_multiply_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_ff_block(*args)
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():
  """multiply_ff() -> gr_multiply_ff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ff()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_check_topology(self, *args)

gr_multiply_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ii_sptr_swigregister
gr_multiply_ii_sptr_swigregister(gr_multiply_ii_sptr)


def gr_multiply_ii_block(*args):
  """gr_multiply_ii_block(gr_multiply_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_ii_block(*args)
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():
  """multiply_ii() -> gr_multiply_ii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ii()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_check_topology(self, *args)

gr_multiply_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_ss_sptr_swigregister
gr_multiply_ss_sptr_swigregister(gr_multiply_ss_sptr)


def gr_multiply_ss_block(*args):
  """gr_multiply_ss_block(gr_multiply_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_multiply_ss_block(*args)
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():
  """multiply_ss() -> gr_multiply_ss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_ss()
class gr_multiply_vcc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_vcc_sptr
        __init__(self,  p) -> gr_multiply_vcc_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_vcc_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_multiply_vcc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_vcc_sptr_swigregister
gr_multiply_vcc_sptr_swigregister(gr_multiply_vcc_sptr)


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


def multiply_vcc(*args):
  """multiply_vcc(size_t nitems_per_block) -> gr_multiply_vcc_sptr"""
  return _gnuradio_swig_py_gengen.multiply_vcc(*args)
class gr_multiply_vff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_vff_sptr
        __init__(self,  p) -> gr_multiply_vff_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_vff_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_multiply_vff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_vff_sptr_swigregister
gr_multiply_vff_sptr_swigregister(gr_multiply_vff_sptr)


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


def multiply_vff(*args):
  """multiply_vff(size_t nitems_per_block) -> gr_multiply_vff_sptr"""
  return _gnuradio_swig_py_gengen.multiply_vff(*args)
class gr_multiply_vii_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_vii_sptr
        __init__(self,  p) -> gr_multiply_vii_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_vii_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_multiply_vii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_vii_sptr_swigregister
gr_multiply_vii_sptr_swigregister(gr_multiply_vii_sptr)


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


def multiply_vii(*args):
  """multiply_vii(size_t nitems_per_block) -> gr_multiply_vii_sptr"""
  return _gnuradio_swig_py_gengen.multiply_vii(*args)
class gr_multiply_vss_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_multiply_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_vss_sptr
        __init__(self,  p) -> gr_multiply_vss_sptr
        """
        this = _gnuradio_swig_py_gengen.new_gr_multiply_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_gengen.gr_multiply_vss_sptr___deref__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

gr_multiply_vss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_multiply_vss_sptr_swigregister
gr_multiply_vss_sptr_swigregister(gr_multiply_vss_sptr)


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


def multiply_vss(*args):
  """multiply_vss(size_t nitems_per_block) -> gr_multiply_vss_sptr"""
  return _gnuradio_swig_py_gengen.multiply_vss(*args)
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):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_set_mute(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_cc_sptr_check_topology(self, *args)

gr_mute_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_cc_sptr_swigregister
gr_mute_cc_sptr_swigregister(gr_mute_cc_sptr)


def gr_mute_cc_block(*args):
  """gr_mute_cc_block(gr_mute_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_mute_cc_block(*args)
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 ())

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):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_set_mute(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ff_sptr_check_topology(self, *args)

gr_mute_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ff_sptr_swigregister
gr_mute_ff_sptr_swigregister(gr_mute_ff_sptr)

def mute_cc(mute = False):
  """
    mute_cc(bool mute = False) -> gr_mute_cc_sptr
    mute_cc() -> gr_mute_cc_sptr
    """
  return _gnuradio_swig_py_gengen.mute_cc(mute)


def gr_mute_ff_block(*args):
  """gr_mute_ff_block(gr_mute_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_mute_ff_block(*args)
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 ())

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):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_set_mute(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ii_sptr_check_topology(self, *args)

gr_mute_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ii_sptr_swigregister
gr_mute_ii_sptr_swigregister(gr_mute_ii_sptr)

def mute_ff(mute = False):
  """
    mute_ff(bool mute = False) -> gr_mute_ff_sptr
    mute_ff() -> gr_mute_ff_sptr
    """
  return _gnuradio_swig_py_gengen.mute_ff(mute)


def gr_mute_ii_block(*args):
  """gr_mute_ii_block(gr_mute_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_mute_ii_block(*args)
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 ())

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):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_set_mute(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_mute_ss_sptr_check_topology(self, *args)

gr_mute_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_mute_ss_sptr_swigregister
gr_mute_ss_sptr_swigregister(gr_mute_ss_sptr)

def mute_ii(mute = False):
  """
    mute_ii(bool mute = False) -> gr_mute_ii_sptr
    mute_ii() -> gr_mute_ii_sptr
    """
  return _gnuradio_swig_py_gengen.mute_ii(mute)


def gr_mute_ss_block(*args):
  """gr_mute_ss_block(gr_mute_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_mute_ss_block(*args)
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 ())

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):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_type(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_amplitude(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_c_sptr_check_topology(self, *args)

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)

def mute_ss(mute = False):
  """
    mute_ss(bool mute = False) -> gr_mute_ss_sptr
    mute_ss() -> gr_mute_ss_sptr
    """
  return _gnuradio_swig_py_gengen.mute_ss(mute)


def gr_noise_source_c_block(*args):
  """gr_noise_source_c_block(gr_noise_source_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_noise_source_c_block(*args)
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 ())

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):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_type(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_amplitude(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_f_sptr_check_topology(self, *args)

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)

def noise_source_c(*args):
  """
    noise_source_c(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_c_sptr
    noise_source_c(gr_noise_type_t type, float ampl) -> gr_noise_source_c_sptr
    """
  return _gnuradio_swig_py_gengen.noise_source_c(*args)


def gr_noise_source_f_block(*args):
  """gr_noise_source_f_block(gr_noise_source_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_noise_source_f_block(*args)
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 ())

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):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_type(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_amplitude(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_i_sptr_check_topology(self, *args)

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)

def noise_source_f(*args):
  """
    noise_source_f(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_f_sptr
    noise_source_f(gr_noise_type_t type, float ampl) -> gr_noise_source_f_sptr
    """
  return _gnuradio_swig_py_gengen.noise_source_f(*args)


def gr_noise_source_i_block(*args):
  """gr_noise_source_i_block(gr_noise_source_i_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_noise_source_i_block(*args)
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 ())

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):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_type(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, float ampl)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_amplitude(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_noise_source_s_sptr_check_topology(self, *args)

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)

def noise_source_i(*args):
  """
    noise_source_i(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_i_sptr
    noise_source_i(gr_noise_type_t type, float ampl) -> gr_noise_source_i_sptr
    """
  return _gnuradio_swig_py_gengen.noise_source_i(*args)


def gr_noise_source_s_block(*args):
  """gr_noise_source_s_block(gr_noise_source_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_noise_source_s_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_bb_sptr_check_topology(self, *args)

gr_not_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_bb_sptr_swigregister
gr_not_bb_sptr_swigregister(gr_not_bb_sptr)

def noise_source_s(*args):
  """
    noise_source_s(gr_noise_type_t type, float ampl, long seed = 3021) -> gr_noise_source_s_sptr
    noise_source_s(gr_noise_type_t type, float ampl) -> gr_noise_source_s_sptr
    """
  return _gnuradio_swig_py_gengen.noise_source_s(*args)


def gr_not_bb_block(*args):
  """gr_not_bb_block(gr_not_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_not_bb_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ii_sptr_check_topology(self, *args)

gr_not_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_ii_sptr_swigregister
gr_not_ii_sptr_swigregister(gr_not_ii_sptr)


def gr_not_ii_block(*args):
  """gr_not_ii_block(gr_not_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_not_ii_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_not_ss_sptr_check_topology(self, *args)

gr_not_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_not_ss_sptr_swigregister
gr_not_ss_sptr_swigregister(gr_not_ss_sptr)


def gr_not_ss_block(*args):
  """gr_not_ss_block(gr_not_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_not_ss_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_bb_sptr_check_topology(self, *args)

gr_or_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_bb_sptr_swigregister
gr_or_bb_sptr_swigregister(gr_or_bb_sptr)


def gr_or_bb_block(*args):
  """gr_or_bb_block(gr_or_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_or_bb_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ii_sptr_check_topology(self, *args)

gr_or_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_ii_sptr_swigregister
gr_or_ii_sptr_swigregister(gr_or_ii_sptr)


def gr_or_ii_block(*args):
  """gr_or_ii_block(gr_or_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_or_ii_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_or_ss_sptr_check_topology(self, *args)

gr_or_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_or_ss_sptr_swigregister
gr_or_ss_sptr_swigregister(gr_or_ss_sptr)


def gr_or_ss_block(*args):
  """gr_or_ss_block(gr_or_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_or_ss_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_sptr_check_topology(self, *args)

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)


def gr_packed_to_unpacked_bb_block(*args):
  """gr_packed_to_unpacked_bb_block(gr_packed_to_unpacked_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_bb_block(*args)
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):
  """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)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_sptr_check_topology(self, *args)

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)


def gr_packed_to_unpacked_ii_block(*args):
  """gr_packed_to_unpacked_ii_block(gr_packed_to_unpacked_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ii_block(*args)
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):
  """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)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_sptr_check_topology(self, *args)

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)


def gr_packed_to_unpacked_ss_block(*args):
  """gr_packed_to_unpacked_ss_block(gr_packed_to_unpacked_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_packed_to_unpacked_ss_block(*args)
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):
  """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)
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):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_threshold_factor_rise(self, *args)

    def set_threshold_factor_fall(self, *args):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_threshold_factor_fall(self, *args)

    def set_look_ahead(self, *args):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_look_ahead(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_alpha(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_fb_sptr_check_topology(self, *args)

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)


def gr_peak_detector_fb_block(*args):
  """gr_peak_detector_fb_block(gr_peak_detector_fb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_peak_detector_fb_block(*args)
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 ())

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):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_threshold_factor_rise(self, *args)

    def set_threshold_factor_fall(self, *args):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_threshold_factor_fall(self, *args)

    def set_look_ahead(self, *args):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_look_ahead(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_alpha(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_ib_sptr_check_topology(self, *args)

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)

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
    peak_detector_fb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10) -> gr_peak_detector_fb_sptr
    peak_detector_fb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40) -> gr_peak_detector_fb_sptr
    peak_detector_fb(float threshold_factor_rise = 0.25) -> gr_peak_detector_fb_sptr
    peak_detector_fb() -> gr_peak_detector_fb_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_fb(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)


def gr_peak_detector_ib_block(*args):
  """gr_peak_detector_ib_block(gr_peak_detector_ib_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_peak_detector_ib_block(*args)
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 ())

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):
        """set_threshold_factor_rise(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_threshold_factor_rise(self, *args)

    def set_threshold_factor_fall(self, *args):
        """set_threshold_factor_fall(self, float thr)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_threshold_factor_fall(self, *args)

    def set_look_ahead(self, *args):
        """set_look_ahead(self, int look)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_look_ahead(self, *args)

    def set_alpha(self, *args):
        """set_alpha(self, int alpha)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_alpha(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_peak_detector_sb_sptr_check_topology(self, *args)

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)

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
    peak_detector_ib(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10) -> gr_peak_detector_ib_sptr
    peak_detector_ib(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40) -> gr_peak_detector_ib_sptr
    peak_detector_ib(float threshold_factor_rise = 0.25) -> gr_peak_detector_ib_sptr
    peak_detector_ib() -> gr_peak_detector_ib_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_ib(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)


def gr_peak_detector_sb_block(*args):
  """gr_peak_detector_sb_block(gr_peak_detector_sb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_peak_detector_sb_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_sptr_check_topology(self, *args)

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)

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
    peak_detector_sb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40, 
        int look_ahead = 10) -> gr_peak_detector_sb_sptr
    peak_detector_sb(float threshold_factor_rise = 0.25, float threshold_factor_fall = 0.40) -> gr_peak_detector_sb_sptr
    peak_detector_sb(float threshold_factor_rise = 0.25) -> gr_peak_detector_sb_sptr
    peak_detector_sb() -> gr_peak_detector_sb_sptr
    """
  return _gnuradio_swig_py_gengen.peak_detector_sb(threshold_factor_rise, threshold_factor_fall, look_ahead, 
    alpha)


def gr_sample_and_hold_bb_block(*args):
  """gr_sample_and_hold_bb_block(gr_sample_and_hold_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sample_and_hold_bb_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_sptr_check_topology(self, *args)

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)


def gr_sample_and_hold_ff_block(*args):
  """gr_sample_and_hold_ff_block(gr_sample_and_hold_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sample_and_hold_ff_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_sptr_check_topology(self, *args)

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)


def gr_sample_and_hold_ii_block(*args):
  """gr_sample_and_hold_ii_block(gr_sample_and_hold_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sample_and_hold_ii_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_sptr_check_topology(self, *args)

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)


def gr_sample_and_hold_ss_block(*args):
  """gr_sample_and_hold_ss_block(gr_sample_and_hold_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sample_and_hold_ss_block(*args)
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):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_sampling_freq(self, *args)

    def set_waveform(self, *args):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_waveform(self, *args)

    def set_frequency(self, *args):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_frequency(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_amplitude(self, *args)

    def set_offset(self, *args):
        """set_offset(self, gr_complex offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_offset(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_c_sptr_check_topology(self, *args)

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)


def gr_sig_source_c_block(*args):
  """gr_sig_source_c_block(gr_sig_source_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sig_source_c_block(*args)
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 ())

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):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_sampling_freq(self, *args)

    def set_waveform(self, *args):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_waveform(self, *args)

    def set_frequency(self, *args):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_frequency(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_amplitude(self, *args)

    def set_offset(self, *args):
        """set_offset(self, float offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_offset(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_f_sptr_check_topology(self, *args)

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)

def sig_source_c(*args):
  """
    sig_source_c(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, gr_complex offset = 0) -> gr_sig_source_c_sptr
    sig_source_c(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl) -> gr_sig_source_c_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_c(*args)


def gr_sig_source_f_block(*args):
  """gr_sig_source_f_block(gr_sig_source_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sig_source_f_block(*args)
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 ())

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):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_sampling_freq(self, *args)

    def set_waveform(self, *args):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_waveform(self, *args)

    def set_frequency(self, *args):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_frequency(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_amplitude(self, *args)

    def set_offset(self, *args):
        """set_offset(self, int offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_offset(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_i_sptr_check_topology(self, *args)

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)

def sig_source_f(*args):
  """
    sig_source_f(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, float offset = 0) -> gr_sig_source_f_sptr
    sig_source_f(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl) -> gr_sig_source_f_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_f(*args)


def gr_sig_source_i_block(*args):
  """gr_sig_source_i_block(gr_sig_source_i_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sig_source_i_block(*args)
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 ())

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):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_sampling_freq(self, *args)

    def set_waveform(self, *args):
        """set_waveform(self, gr_waveform_t waveform)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_waveform(self, *args)

    def set_frequency(self, *args):
        """set_frequency(self, double frequency)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_frequency(self, *args)

    def set_amplitude(self, *args):
        """set_amplitude(self, double ampl)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_amplitude(self, *args)

    def set_offset(self, *args):
        """set_offset(self, short offset)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_offset(self, *args)

    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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sig_source_s_sptr_check_topology(self, *args)

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)

def sig_source_i(*args):
  """
    sig_source_i(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, int offset = 0) -> gr_sig_source_i_sptr
    sig_source_i(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl) -> gr_sig_source_i_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_i(*args)


def gr_sig_source_s_block(*args):
  """gr_sig_source_s_block(gr_sig_source_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sig_source_s_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_cc_sptr_check_topology(self, *args)

gr_sub_cc_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_cc_sptr_swigregister
gr_sub_cc_sptr_swigregister(gr_sub_cc_sptr)

def sig_source_s(*args):
  """
    sig_source_s(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl, short offset = 0) -> gr_sig_source_s_sptr
    sig_source_s(double sampling_freq, gr_waveform_t waveform, double wave_freq, 
        double ampl) -> gr_sig_source_s_sptr
    """
  return _gnuradio_swig_py_gengen.sig_source_s(*args)


def gr_sub_cc_block(*args):
  """gr_sub_cc_block(gr_sub_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sub_cc_block(*args)
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():
  """sub_cc() -> gr_sub_cc_sptr"""
  return _gnuradio_swig_py_gengen.sub_cc()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ff_sptr_check_topology(self, *args)

gr_sub_ff_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ff_sptr_swigregister
gr_sub_ff_sptr_swigregister(gr_sub_ff_sptr)


def gr_sub_ff_block(*args):
  """gr_sub_ff_block(gr_sub_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sub_ff_block(*args)
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():
  """sub_ff() -> gr_sub_ff_sptr"""
  return _gnuradio_swig_py_gengen.sub_ff()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ii_sptr_check_topology(self, *args)

gr_sub_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ii_sptr_swigregister
gr_sub_ii_sptr_swigregister(gr_sub_ii_sptr)


def gr_sub_ii_block(*args):
  """gr_sub_ii_block(gr_sub_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sub_ii_block(*args)
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():
  """sub_ii() -> gr_sub_ii_sptr"""
  return _gnuradio_swig_py_gengen.sub_ii()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_sub_ss_sptr_check_topology(self, *args)

gr_sub_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_sub_ss_sptr_swigregister
gr_sub_ss_sptr_swigregister(gr_sub_ss_sptr)


def gr_sub_ss_block(*args):
  """gr_sub_ss_block(gr_sub_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_sub_ss_block(*args)
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():
  """sub_ss() -> gr_sub_ss_sptr"""
  return _gnuradio_swig_py_gengen.sub_ss()
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_sptr_check_topology(self, *args)

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)


def gr_unpacked_to_packed_bb_block(*args):
  """gr_unpacked_to_packed_bb_block(gr_unpacked_to_packed_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_bb_block(*args)
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):
  """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)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_sptr_check_topology(self, *args)

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)


def gr_unpacked_to_packed_ii_block(*args):
  """gr_unpacked_to_packed_ii_block(gr_unpacked_to_packed_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ii_block(*args)
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):
  """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)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_sptr_check_topology(self, *args)

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)


def gr_unpacked_to_packed_ss_block(*args):
  """gr_unpacked_to_packed_ss_block(gr_unpacked_to_packed_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_unpacked_to_packed_ss_block(*args)
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):
  """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)
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_b_sptr_check_topology(self, *args)

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)


def gr_vector_sink_b_block(*args):
  """gr_vector_sink_b_block(gr_vector_sink_b_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_sink_b_block(*args)
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():
  """vector_sink_b() -> gr_vector_sink_b_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_b()
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_c_sptr_check_topology(self, *args)

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)


def gr_vector_sink_c_block(*args):
  """gr_vector_sink_c_block(gr_vector_sink_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_sink_c_block(*args)
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():
  """vector_sink_c() -> gr_vector_sink_c_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_c()
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_f_sptr_check_topology(self, *args)

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)


def gr_vector_sink_f_block(*args):
  """gr_vector_sink_f_block(gr_vector_sink_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_sink_f_block(*args)
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():
  """vector_sink_f() -> gr_vector_sink_f_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_f()
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_i_sptr_check_topology(self, *args)

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)


def gr_vector_sink_i_block(*args):
  """gr_vector_sink_i_block(gr_vector_sink_i_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_sink_i_block(*args)
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():
  """vector_sink_i() -> gr_vector_sink_i_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_i()
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_sink_s_sptr_check_topology(self, *args)

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)


def gr_vector_sink_s_block(*args):
  """gr_vector_sink_s_block(gr_vector_sink_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_sink_s_block(*args)
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():
  """vector_sink_s() -> gr_vector_sink_s_sptr"""
  return _gnuradio_swig_py_gengen.vector_sink_s()
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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_b_sptr_check_topology(self, *args)

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)


def gr_vector_source_b_block(*args):
  """gr_vector_source_b_block(gr_vector_source_b_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_source_b_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_c_sptr_check_topology(self, *args)

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)

def vector_source_b(*args):
  """
    vector_source_b(__dummy_0__ data, bool repeat = False) -> gr_vector_source_b_sptr
    vector_source_b(__dummy_0__ data) -> gr_vector_source_b_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_b(*args)


def gr_vector_source_c_block(*args):
  """gr_vector_source_c_block(gr_vector_source_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_source_c_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_f_sptr_check_topology(self, *args)

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)

def vector_source_c(*args):
  """
    vector_source_c(std::vector<(gr_complex,std::allocator<(gr_complex)>)> data, 
        bool repeat = False) -> gr_vector_source_c_sptr
    vector_source_c(std::vector<(gr_complex,std::allocator<(gr_complex)>)> data) -> gr_vector_source_c_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_c(*args)


def gr_vector_source_f_block(*args):
  """gr_vector_source_f_block(gr_vector_source_f_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_source_f_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_i_sptr_check_topology(self, *args)

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)

def vector_source_f(*args):
  """
    vector_source_f(__dummy_4__ data, bool repeat = False) -> gr_vector_source_f_sptr
    vector_source_f(__dummy_4__ data) -> gr_vector_source_f_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_f(*args)


def gr_vector_source_i_block(*args):
  """gr_vector_source_i_block(gr_vector_source_i_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_source_i_block(*args)
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 ())

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 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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_vector_source_s_sptr_check_topology(self, *args)

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)

def vector_source_i(*args):
  """
    vector_source_i(__dummy_3__ data, bool repeat = False) -> gr_vector_source_i_sptr
    vector_source_i(__dummy_3__ data) -> gr_vector_source_i_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_i(*args)


def gr_vector_source_s_block(*args):
  """gr_vector_source_s_block(gr_vector_source_s_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_vector_source_s_block(*args)
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 ())

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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_bb_sptr_check_topology(self, *args)

gr_xor_bb_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_bb_sptr_swigregister
gr_xor_bb_sptr_swigregister(gr_xor_bb_sptr)

def vector_source_s(*args):
  """
    vector_source_s(__dummy_2__ data, bool repeat = False) -> gr_vector_source_s_sptr
    vector_source_s(__dummy_2__ data) -> gr_vector_source_s_sptr
    """
  return _gnuradio_swig_py_gengen.vector_source_s(*args)


def gr_xor_bb_block(*args):
  """gr_xor_bb_block(gr_xor_bb_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_xor_bb_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ii_sptr_check_topology(self, *args)

gr_xor_ii_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_ii_sptr_swigregister
gr_xor_ii_sptr_swigregister(gr_xor_ii_sptr)


def gr_xor_ii_block(*args):
  """gr_xor_ii_block(gr_xor_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_xor_ii_block(*args)
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):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_set_detail(self, *args)

    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):
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_py_gengen.gr_xor_ss_sptr_check_topology(self, *args)

gr_xor_ss_sptr_swigregister = _gnuradio_swig_py_gengen.gr_xor_ss_sptr_swigregister
gr_xor_ss_sptr_swigregister(gr_xor_ss_sptr)


def gr_xor_ss_block(*args):
  """gr_xor_ss_block(gr_xor_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_py_gengen.gr_xor_ss_block(*args)
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()


