# 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_runtime', [dirname(__file__)])
        except ImportError:
            import _gnuradio_swig_py_runtime
            return _gnuradio_swig_py_runtime
        if fp is not None:
            try:
                _mod = imp.load_module('_gnuradio_swig_py_runtime', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _gnuradio_swig_py_runtime = swig_import_helper()
    del swig_import_helper
else:
    import _gnuradio_swig_py_runtime
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sizeof_char = _gnuradio_swig_py_runtime.sizeof_char
sizeof_short = _gnuradio_swig_py_runtime.sizeof_short
sizeof_int = _gnuradio_swig_py_runtime.sizeof_int
sizeof_float = _gnuradio_swig_py_runtime.sizeof_float
sizeof_double = _gnuradio_swig_py_runtime.sizeof_double
sizeof_gr_complex = _gnuradio_swig_py_runtime.sizeof_gr_complex
class gr_io_signature_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_io_signature)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_io_signature_sptr
        __init__(self, gr_io_signature p) -> gr_io_signature_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_io_signature_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_io_signature"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_io_signature_sptr
    __del__ = lambda self : None;
    def min_streams(self):
        """min_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_min_streams(self)

    def max_streams(self):
        """max_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_max_streams(self)

    def sizeof_stream_item(self, *args):
        """sizeof_stream_item(self, int index) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_sizeof_stream_item(self, *args)

    def sizeof_stream_items(self):
        """sizeof_stream_items(self) -> __dummy_3__"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sptr_sizeof_stream_items(self)

gr_io_signature_sptr_swigregister = _gnuradio_swig_py_runtime.gr_io_signature_sptr_swigregister
gr_io_signature_sptr_swigregister(gr_io_signature_sptr)


def io_signature(*args):
  """io_signature(int min_streams, int max_streams, int sizeof_stream_item) -> gr_io_signature_sptr"""
  return _gnuradio_swig_py_runtime.io_signature(*args)

def io_signature2(*args):
  """
    io_signature2(int min_streams, int max_streams, int sizeof_stream_item1, 
        int sizeof_stream_item2) -> gr_io_signature_sptr
    """
  return _gnuradio_swig_py_runtime.io_signature2(*args)

def io_signature3(*args):
  """
    io_signature3(int min_streams, int max_streams, int sizeof_stream_item1, 
        int sizeof_stream_item2, int sizeof_stream_item3) -> gr_io_signature_sptr
    """
  return _gnuradio_swig_py_runtime.io_signature3(*args)

def io_signaturev(*args):
  """io_signaturev(int min_streams, int max_streams, __dummy_3__ sizeof_stream_items) -> gr_io_signature_sptr"""
  return _gnuradio_swig_py_runtime.io_signaturev(*args)
class gr_io_signature(object):
    """Proxy of C++ gr_io_signature class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_io_signature
    __del__ = lambda self : None;
    def min_streams(self):
        """min_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_min_streams(self)

    def max_streams(self):
        """max_streams(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_max_streams(self)

    def sizeof_stream_item(self, *args):
        """sizeof_stream_item(self, int index) -> int"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sizeof_stream_item(self, *args)

    def sizeof_stream_items(self):
        """sizeof_stream_items(self) -> __dummy_3__"""
        return _gnuradio_swig_py_runtime.gr_io_signature_sizeof_stream_items(self)

gr_io_signature_swigregister = _gnuradio_swig_py_runtime.gr_io_signature_swigregister
gr_io_signature_swigregister(gr_io_signature)

class gr_buffer_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_buffer)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_sptr
        __init__(self,  p) -> gr_buffer_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_buffer_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_buffer_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_buffer_sptr
    __del__ = lambda self : None;
gr_buffer_sptr_swigregister = _gnuradio_swig_py_runtime.gr_buffer_sptr_swigregister
gr_buffer_sptr_swigregister(gr_buffer_sptr)


def buffer(*args):
  """buffer(int nitems, size_t sizeof_item) -> gr_buffer_sptr"""
  return _gnuradio_swig_py_runtime.buffer(*args)
class gr_buffer_reader_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_buffer_reader)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_reader_sptr
        __init__(self,  p) -> gr_buffer_reader_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_buffer_reader_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_buffer_reader_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_buffer_reader_sptr
    __del__ = lambda self : None;
gr_buffer_reader_sptr_swigregister = _gnuradio_swig_py_runtime.gr_buffer_reader_sptr_swigregister
gr_buffer_reader_sptr_swigregister(gr_buffer_reader_sptr)


def buffer_add_reader(*args):
  """buffer_add_reader(gr_buffer_sptr buf, int nzero_preload) -> gr_buffer_reader_sptr"""
  return _gnuradio_swig_py_runtime.buffer_add_reader(*args)

def buffer_ncurrently_allocated():
  """buffer_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.buffer_ncurrently_allocated()

def buffer_reader_ncurrently_allocated():
  """buffer_reader_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.buffer_reader_ncurrently_allocated()
class gr_basic_block_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_basic_block)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_basic_block_sptr
        __init__(self, gr_basic_block p) -> gr_basic_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_basic_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_basic_block"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_basic_block_sptr
    __del__ = lambda self : None;
    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_sptr_basic_block(self)

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

gr_basic_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_basic_block_sptr_swigregister
gr_basic_block_sptr_swigregister(gr_basic_block_sptr)

class x_vector_gr_basic_block_sptr(object):
    """Proxy of C++ std::vector<(gr_basic_block_sptr)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j) -> x_vector_gr_basic_block_sptr
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j, 
            x_vector_gr_basic_block_sptr v)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type j)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> x_vector_gr_basic_block_sptr
        __getitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, x_vector_gr_basic_block_sptr v)
        __setitem__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_empty(self)

    def size(self):
        """size(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_size(self)

    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_clear(self)

    def swap(self, *args):
        """swap(self, x_vector_gr_basic_block_sptr v)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::allocator_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_begin(self)

    def end(self):
        """end(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        erase(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator first, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator last) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> x_vector_gr_basic_block_sptr
        __init__(self, x_vector_gr_basic_block_sptr arg0) -> x_vector_gr_basic_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type size) -> x_vector_gr_basic_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type size, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type value) -> x_vector_gr_basic_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_x_vector_gr_basic_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_front(self)

    def back(self):
        """back(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_back(self)

    def assign(self, *args):
        """
        assign(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type new_size)
        resize(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type new_size, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator
        insert(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_basic_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type n)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(boost::shared_ptr<(gr_basic_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_capacity(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_x_vector_gr_basic_block_sptr
    __del__ = lambda self : None;
x_vector_gr_basic_block_sptr_swigregister = _gnuradio_swig_py_runtime.x_vector_gr_basic_block_sptr_swigregister
x_vector_gr_basic_block_sptr_swigregister(x_vector_gr_basic_block_sptr)

class gr_basic_block(object):
    """Proxy of C++ gr_basic_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_basic_block
    __del__ = lambda self : None;
    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_basic_block_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_basic_block_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_basic_block_basic_block(self)

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

gr_basic_block_swigregister = _gnuradio_swig_py_runtime.gr_basic_block_swigregister
gr_basic_block_swigregister(gr_basic_block)


def block_ncurrently_allocated():
  """block_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.block_ncurrently_allocated()
gr_basic_block_sptr.__repr__ = lambda self: "<gr_basic_block %s (%d)>" % (self.name(), self.unique_id ())

class gr_block_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_block)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_block_sptr
        __init__(self, gr_block p) -> gr_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_block"""
        return _gnuradio_swig_py_runtime.gr_block_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block_sptr
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_set_detail(self, *args)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_sptr_basic_block(self)

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

gr_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_block_sptr_swigregister
gr_block_sptr_swigregister(gr_block_sptr)

class x_vector_gr_block_sptr(object):
    """Proxy of C++ std::vector<(gr_block_sptr)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j) -> x_vector_gr_block_sptr
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j, 
            x_vector_gr_block_sptr v)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> x_vector_gr_block_sptr
        __getitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, x_vector_gr_block_sptr v)
        __setitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_empty(self)

    def size(self):
        """size(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_size(self)

    def clear(self):
        """clear(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_clear(self)

    def swap(self, *args):
        """swap(self, x_vector_gr_block_sptr v)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::allocator_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_begin(self)

    def end(self):
        """end(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        erase(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator first, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::iterator last) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> x_vector_gr_block_sptr
        __init__(self, x_vector_gr_block_sptr arg0) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type value) -> x_vector_gr_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_x_vector_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_front(self)

    def back(self):
        """back(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_back(self)

    def assign(self, *args):
        """
        assign(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size)
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        insert(self, std::vector<(boost::shared_ptr<(gr_block)>)>::iterator pos, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n)"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_capacity(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_x_vector_gr_block_sptr
    __del__ = lambda self : None;
x_vector_gr_block_sptr_swigregister = _gnuradio_swig_py_runtime.x_vector_gr_block_sptr_swigregister
x_vector_gr_block_sptr_swigregister(x_vector_gr_block_sptr)

class gr_block(gr_basic_block):
    """Proxy of C++ gr_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block
    __del__ = lambda self : None;
    def history(self):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_block_history(self)

    def output_multiple(self):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_output_multiple(self)

    def relative_rate(self):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_block_relative_rate(self)

    def start(self):
        """start(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_start(self)

    def stop(self):
        """stop(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_stop(self)

    def detail(self):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail(self)

    def set_detail(self, *args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_py_runtime.gr_block_set_detail(self, *args)

gr_block_swigregister = _gnuradio_swig_py_runtime.gr_block_swigregister
gr_block_swigregister(gr_block)

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

class gr_block_detail_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_block_detail)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_block_detail_sptr
        __init__(self,  p) -> gr_block_detail_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_block_detail_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_block_detail_sptr
    __del__ = lambda self : None;
    def ninputs(self):
        """ninputs(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_ninputs(self)

    def noutputs(self):
        """noutputs(self) -> int"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_noutputs(self)

    def sink_p(self):
        """sink_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_sink_p(self)

    def source_p(self):
        """source_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_source_p(self)

    def set_input(self, *args):
        """set_input(self, unsigned int which, gr_buffer_reader_sptr reader)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_set_input(self, *args)

    def input(self, *args):
        """input(self, unsigned int which) -> gr_buffer_reader_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_input(self, *args)

    def set_output(self, *args):
        """set_output(self, unsigned int which, gr_buffer_sptr buffer)"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_set_output(self, *args)

    def output(self, *args):
        """output(self, unsigned int which) -> gr_buffer_sptr"""
        return _gnuradio_swig_py_runtime.gr_block_detail_sptr_output(self, *args)

gr_block_detail_sptr_swigregister = _gnuradio_swig_py_runtime.gr_block_detail_sptr_swigregister
gr_block_detail_sptr_swigregister(gr_block_detail_sptr)


def block_detail(*args):
  """block_detail(unsigned int ninputs, unsigned int noutputs) -> gr_block_detail_sptr"""
  return _gnuradio_swig_py_runtime.block_detail(*args)

def block_detail_ncurrently_allocated():
  """block_detail_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.block_detail_ncurrently_allocated()
class gr_hier_block2_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_hier_block2)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_hier_block2_sptr
        __init__(self, gr_hier_block2 p) -> gr_hier_block2_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_hier_block2_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_hier_block2"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_hier_block2_sptr
    __del__ = lambda self : None;
    def connect(self, *args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_connect(self, *args)

    def disconnect(self, *args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_disconnect(self, *args)

    def disconnect_all(self):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_disconnect_all(self)

    def lock(self):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_unlock(self)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_sptr_basic_block(self)

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

gr_hier_block2_sptr_swigregister = _gnuradio_swig_py_runtime.gr_hier_block2_sptr_swigregister
gr_hier_block2_sptr_swigregister(gr_hier_block2_sptr)


def hier_block2_swig(*args):
  """
    hier_block2_swig(string name, gr_io_signature_sptr input_signature, 
        gr_io_signature_sptr output_signature) -> gr_hier_block2_sptr
    """
  return _gnuradio_swig_py_runtime.hier_block2_swig(*args)
class gr_hier_block2(gr_basic_block):
    """Proxy of C++ gr_hier_block2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_hier_block2
    __del__ = lambda self : None;
    def connect(self, *args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_connect(self, *args)

    def disconnect(self, *args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_hier_block2_disconnect(self, *args)

    def disconnect_all(self):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_disconnect_all(self)

    def lock(self):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_hier_block2_unlock(self)

gr_hier_block2_swigregister = _gnuradio_swig_py_runtime.gr_hier_block2_swigregister
gr_hier_block2_swigregister(gr_hier_block2)

class gr_single_threaded_scheduler_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_single_threaded_scheduler)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_single_threaded_scheduler_sptr
        __init__(self,  p) -> gr_single_threaded_scheduler_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_single_threaded_scheduler_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_single_threaded_scheduler_sptr
    __del__ = lambda self : None;
    def stop(self):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr_stop(self)

gr_single_threaded_scheduler_sptr_swigregister = _gnuradio_swig_py_runtime.gr_single_threaded_scheduler_sptr_swigregister
gr_single_threaded_scheduler_sptr_swigregister(gr_single_threaded_scheduler_sptr)


def single_threaded_scheduler(*args):
  """single_threaded_scheduler(x_vector_gr_block_sptr modules) -> gr_single_threaded_scheduler_sptr"""
  return _gnuradio_swig_py_runtime.single_threaded_scheduler(*args)

def sts_pyrun(*args):
  """sts_pyrun(gr_single_threaded_scheduler_sptr s)"""
  return _gnuradio_swig_py_runtime.sts_pyrun(*args)
class gr_message_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_message)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_message_sptr
        __init__(self, gr_message p) -> gr_message_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_message_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_message"""
        return _gnuradio_swig_py_runtime.gr_message_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_message_sptr
    __del__ = lambda self : None;
    def type(self):
        """type(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_type(self)

    def arg1(self):
        """arg1(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_arg1(self)

    def arg2(self):
        """arg2(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_arg2(self)

    def set_type(self, *args):
        """set_type(self, long type)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_type(self, *args)

    def set_arg1(self, *args):
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_arg1(self, *args)

    def set_arg2(self, *args):
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_set_arg2(self, *args)

    def length(self):
        """length(self) -> size_t"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_length(self)

    def to_string(self):
        """to_string(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_message_sptr_to_string(self)

gr_message_sptr_swigregister = _gnuradio_swig_py_runtime.gr_message_sptr_swigregister
gr_message_sptr_swigregister(gr_message_sptr)

class gr_message(object):
    """Proxy of C++ gr_message class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_message
    __del__ = lambda self : None;
    def type(self):
        """type(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_message_type(self)

    def arg1(self):
        """arg1(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_arg1(self)

    def arg2(self):
        """arg2(self) -> double"""
        return _gnuradio_swig_py_runtime.gr_message_arg2(self)

    def set_type(self, *args):
        """set_type(self, long type)"""
        return _gnuradio_swig_py_runtime.gr_message_set_type(self, *args)

    def set_arg1(self, *args):
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_py_runtime.gr_message_set_arg1(self, *args)

    def set_arg2(self, *args):
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_py_runtime.gr_message_set_arg2(self, *args)

    def length(self):
        """length(self) -> size_t"""
        return _gnuradio_swig_py_runtime.gr_message_length(self)

    def to_string(self):
        """to_string(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_message_to_string(self)

gr_message_swigregister = _gnuradio_swig_py_runtime.gr_message_swigregister
gr_message_swigregister(gr_message)

def message_from_string(*args):
  """
    message_from_string(string s, long type = 0, double arg1 = 0, double arg2 = 0) -> gr_message_sptr
    message_from_string(string s, long type = 0, double arg1 = 0) -> gr_message_sptr
    message_from_string(string s, long type = 0) -> gr_message_sptr
    message_from_string(string s) -> gr_message_sptr
    """
  return _gnuradio_swig_py_runtime.message_from_string(*args)

def message(type = 0, arg1 = 0, arg2 = 0, length = 0):
  """
    message(long type = 0, double arg1 = 0, double arg2 = 0, size_t length = 0) -> gr_message_sptr
    message(long type = 0, double arg1 = 0, double arg2 = 0) -> gr_message_sptr
    message(long type = 0, double arg1 = 0) -> gr_message_sptr
    message(long type = 0) -> gr_message_sptr
    message() -> gr_message_sptr
    """
  return _gnuradio_swig_py_runtime.message(type, arg1, arg2, length)


def message_ncurrently_allocated():
  """message_ncurrently_allocated() -> long"""
  return _gnuradio_swig_py_runtime.message_ncurrently_allocated()
class gr_msg_handler(object):
    """Proxy of C++ gr_msg_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_msg_handler
    __del__ = lambda self : None;
    def handle(self, *args):
        """handle(self, gr_message_sptr msg)"""
        return _gnuradio_swig_py_runtime.gr_msg_handler_handle(self, *args)

gr_msg_handler_swigregister = _gnuradio_swig_py_runtime.gr_msg_handler_swigregister
gr_msg_handler_swigregister(gr_msg_handler)

class gr_msg_queue_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_msg_queue)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_msg_queue_sptr
        __init__(self,  p) -> gr_msg_queue_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_msg_queue_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_msg_queue_sptr
    __del__ = lambda self : None;
    def delete_head_nowait(self):
        """delete_head_nowait(self) -> gr_message_sptr"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_delete_head_nowait(self)

    def empty_p(self):
        """empty_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_empty_p(self)

    def full_p(self):
        """full_p(self) -> bool"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_full_p(self)

    def count(self):
        """count(self) -> unsigned int"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_count(self)

    def flush(self):
        """flush(self)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_flush(self)

    def handle(self, *args):
        """handle(self, gr_message_sptr msg)"""
        return _gnuradio_swig_py_runtime.gr_msg_queue_sptr_handle(self, *args)

gr_msg_queue_sptr_swigregister = _gnuradio_swig_py_runtime.gr_msg_queue_sptr_swigregister
gr_msg_queue_sptr_swigregister(gr_msg_queue_sptr)


def gr_py_msg_queue__delete_head(*args):
  """gr_py_msg_queue__delete_head(gr_msg_queue_sptr q) -> gr_message_sptr"""
  return _gnuradio_swig_py_runtime.gr_py_msg_queue__delete_head(*args)

def gr_py_msg_queue__insert_tail(*args):
  """gr_py_msg_queue__insert_tail(gr_msg_queue_sptr q, gr_message_sptr msg)"""
  return _gnuradio_swig_py_runtime.gr_py_msg_queue__insert_tail(*args)
gr_msg_queue_sptr.delete_head = gr_py_msg_queue__delete_head
gr_msg_queue_sptr.insert_tail = gr_py_msg_queue__insert_tail
gr_msg_queue_sptr.handle = gr_py_msg_queue__insert_tail

class gr_dispatcher_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_dispatcher)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_dispatcher_sptr
        __init__(self, gr_dispatcher p) -> gr_dispatcher_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_dispatcher_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_dispatcher"""
        return _gnuradio_swig_py_runtime.gr_dispatcher_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_dispatcher_sptr
    __del__ = lambda self : None;
    def loop(self, timeout = 10):
        """
        loop(self, double timeout = 10)
        loop(self)
        """
        return _gnuradio_swig_py_runtime.gr_dispatcher_sptr_loop(self, timeout)

gr_dispatcher_sptr_swigregister = _gnuradio_swig_py_runtime.gr_dispatcher_sptr_swigregister
gr_dispatcher_sptr_swigregister(gr_dispatcher_sptr)

def msg_queue(limit = 0):
  """
    msg_queue(unsigned int limit = 0) -> gr_msg_queue_sptr
    msg_queue() -> gr_msg_queue_sptr
    """
  return _gnuradio_swig_py_runtime.msg_queue(limit)


def dispatcher():
  """dispatcher() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_py_runtime.dispatcher()

def dispatcher_singleton():
  """dispatcher_singleton() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_py_runtime.dispatcher_singleton()
class gr_dispatcher(object):
    """Proxy of C++ gr_dispatcher class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_dispatcher
    __del__ = lambda self : None;
    def loop(self, timeout = 10):
        """
        loop(self, double timeout = 10)
        loop(self)
        """
        return _gnuradio_swig_py_runtime.gr_dispatcher_loop(self, timeout)

gr_dispatcher_swigregister = _gnuradio_swig_py_runtime.gr_dispatcher_swigregister
gr_dispatcher_swigregister(gr_dispatcher)

class error_handler(object):
    """Proxy of C++ gr_error_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    ERR_DEBUG = _gnuradio_swig_py_runtime.error_handler_ERR_DEBUG
    ERR_MESSAGE = _gnuradio_swig_py_runtime.error_handler_ERR_MESSAGE
    ERR_WARNING = _gnuradio_swig_py_runtime.error_handler_ERR_WARNING
    ERR_ERROR = _gnuradio_swig_py_runtime.error_handler_ERR_ERROR
    ERR_FATAL = _gnuradio_swig_py_runtime.error_handler_ERR_FATAL
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_error_handler
    __del__ = lambda self : None;
    def default_handler():
        """default_handler() -> error_handler"""
        return _gnuradio_swig_py_runtime.error_handler_default_handler()

    default_handler = staticmethod(default_handler)
    def silent_handler():
        """silent_handler() -> error_handler"""
        return _gnuradio_swig_py_runtime.error_handler_silent_handler()

    silent_handler = staticmethod(silent_handler)
    def has_default_handler():
        """has_default_handler() -> bool"""
        return _gnuradio_swig_py_runtime.error_handler_has_default_handler()

    has_default_handler = staticmethod(has_default_handler)
    def set_default_handler(*args):
        """set_default_handler(error_handler errh)"""
        return _gnuradio_swig_py_runtime.error_handler_set_default_handler(*args)

    set_default_handler = staticmethod(set_default_handler)
    def nwarnings(self):
        """nwarnings(self) -> int"""
        return _gnuradio_swig_py_runtime.error_handler_nwarnings(self)

    def nerrors(self):
        """nerrors(self) -> int"""
        return _gnuradio_swig_py_runtime.error_handler_nerrors(self)

    def reset_counts(self):
        """reset_counts(self)"""
        return _gnuradio_swig_py_runtime.error_handler_reset_counts(self)

    def verror_text(self, *args):
        """verror_text(self, seriousness s, string text)"""
        return _gnuradio_swig_py_runtime.error_handler_verror_text(self, *args)

error_handler_swigregister = _gnuradio_swig_py_runtime.error_handler_swigregister
error_handler_swigregister(error_handler)

def error_handler_default_handler():
  """error_handler_default_handler() -> error_handler"""
  return _gnuradio_swig_py_runtime.error_handler_default_handler()

def error_handler_silent_handler():
  """error_handler_silent_handler() -> error_handler"""
  return _gnuradio_swig_py_runtime.error_handler_silent_handler()

def error_handler_has_default_handler():
  """error_handler_has_default_handler() -> bool"""
  return _gnuradio_swig_py_runtime.error_handler_has_default_handler()

def error_handler_set_default_handler(*args):
  """error_handler_set_default_handler(error_handler errh)"""
  return _gnuradio_swig_py_runtime.error_handler_set_default_handler(*args)

class file_error_handler(object):
    """Proxy of C++ gr_file_error_handler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, int file_descriptor) -> file_error_handler"""
        this = _gnuradio_swig_py_runtime.new_file_error_handler(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_file_error_handler
    __del__ = lambda self : None;
file_error_handler_swigregister = _gnuradio_swig_py_runtime.file_error_handler_swigregister
file_error_handler_swigregister(file_error_handler)

RT_OK = _gnuradio_swig_py_runtime.RT_OK
RT_NOT_IMPLEMENTED = _gnuradio_swig_py_runtime.RT_NOT_IMPLEMENTED
RT_NO_PRIVS = _gnuradio_swig_py_runtime.RT_NO_PRIVS
RT_OTHER_ERROR = _gnuradio_swig_py_runtime.RT_OTHER_ERROR

def enable_realtime_scheduling():
  """enable_realtime_scheduling() -> gr_rt_status_t"""
  return _gnuradio_swig_py_runtime.enable_realtime_scheduling()
class gr_sync_block(gr_block):
    """Proxy of C++ gr_sync_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_block
    __del__ = lambda self : None;
gr_sync_block_swigregister = _gnuradio_swig_py_runtime.gr_sync_block_swigregister
gr_sync_block_swigregister(gr_sync_block)

class gr_sync_decimator(gr_sync_block):
    """Proxy of C++ gr_sync_decimator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_decimator
    __del__ = lambda self : None;
gr_sync_decimator_swigregister = _gnuradio_swig_py_runtime.gr_sync_decimator_swigregister
gr_sync_decimator_swigregister(gr_sync_decimator)

class gr_sync_interpolator(gr_sync_block):
    """Proxy of C++ gr_sync_interpolator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_sync_interpolator
    __del__ = lambda self : None;
gr_sync_interpolator_swigregister = _gnuradio_swig_py_runtime.gr_sync_interpolator_swigregister
gr_sync_interpolator_swigregister(gr_sync_interpolator)

class gr_top_block_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr_top_block)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> gr_top_block_sptr
        __init__(self, gr_top_block p) -> gr_top_block_sptr
        """
        this = _gnuradio_swig_py_runtime.new_gr_top_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(self) -> gr_top_block"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr___deref__(self)

    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_top_block_sptr
    __del__ = lambda self : None;
    def start(self):
        """start(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_start(self)

    def stop(self):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_stop(self)

    def wait(self):
        """wait(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_wait(self)

    def run(self):
        """run(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_run(self)

    def lock(self):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_unlock(self)

    def dump(self):
        """dump(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_dump(self)

    def connect(self, *args):
        """
        connect(self, gr_basic_block_sptr block)
        connect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_connect(self, *args)

    def disconnect(self, *args):
        """
        disconnect(self, gr_basic_block_sptr block)
        disconnect(self, gr_basic_block_sptr src, int src_port, gr_basic_block_sptr dst, 
            int dst_port)
        """
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_disconnect(self, *args)

    def disconnect_all(self):
        """disconnect_all(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_disconnect_all(self)

    def name(self):
        """name(self) -> string"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_name(self)

    def input_signature(self):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(self) -> long"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_unique_id(self)

    def basic_block(self):
        """basic_block(self) -> gr_basic_block_sptr"""
        return _gnuradio_swig_py_runtime.gr_top_block_sptr_basic_block(self)

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

gr_top_block_sptr_swigregister = _gnuradio_swig_py_runtime.gr_top_block_sptr_swigregister
gr_top_block_sptr_swigregister(gr_top_block_sptr)


def top_block_swig(*args):
  """top_block_swig(string name) -> gr_top_block_sptr"""
  return _gnuradio_swig_py_runtime.top_block_swig(*args)
class gr_top_block(gr_hier_block2):
    """Proxy of C++ gr_top_block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_py_runtime.delete_gr_top_block
    __del__ = lambda self : None;
    def start(self):
        """start(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_start(self)

    def stop(self):
        """stop(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_stop(self)

    def wait(self):
        """wait(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_wait(self)

    def run(self):
        """run(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_run(self)

    def lock(self):
        """lock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_unlock(self)

    def dump(self):
        """dump(self)"""
        return _gnuradio_swig_py_runtime.gr_top_block_dump(self)

gr_top_block_swigregister = _gnuradio_swig_py_runtime.gr_top_block_swigregister
gr_top_block_swigregister(gr_top_block)


def top_block_run_unlocked(*args):
  """top_block_run_unlocked(gr_top_block_sptr r)"""
  return _gnuradio_swig_py_runtime.top_block_run_unlocked(*args)

def top_block_wait_unlocked(*args):
  """top_block_wait_unlocked(gr_top_block_sptr r)"""
  return _gnuradio_swig_py_runtime.top_block_wait_unlocked(*args)


