# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don't modify this file, modify the SWIG interface instead.

import _gnuradio_swig_python
import new
new_instancemethod = new.instancemethod
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__ == 'PySwigObject':
            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,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


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 PySwigIterator(object):
    """Proxy of C++ PySwigIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args):
        """value(self) -> PyObject"""
        return _gnuradio_swig_python.PySwigIterator_value(*args)

    def incr(*args):
        """
        incr(self, size_t n=1) -> PySwigIterator
        incr(self) -> PySwigIterator
        """
        return _gnuradio_swig_python.PySwigIterator_incr(*args)

    def decr(*args):
        """
        decr(self, size_t n=1) -> PySwigIterator
        decr(self) -> PySwigIterator
        """
        return _gnuradio_swig_python.PySwigIterator_decr(*args)

    def distance(*args):
        """distance(self, PySwigIterator x) -> ptrdiff_t"""
        return _gnuradio_swig_python.PySwigIterator_distance(*args)

    def equal(*args):
        """equal(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_python.PySwigIterator_equal(*args)

    def copy(*args):
        """copy(self) -> PySwigIterator"""
        return _gnuradio_swig_python.PySwigIterator_copy(*args)

    def next(*args):
        """next(self) -> PyObject"""
        return _gnuradio_swig_python.PySwigIterator_next(*args)

    def previous(*args):
        """previous(self) -> PyObject"""
        return _gnuradio_swig_python.PySwigIterator_previous(*args)

    def advance(*args):
        """advance(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_python.PySwigIterator_advance(*args)

    def __eq__(*args):
        """__eq__(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_python.PySwigIterator___eq__(*args)

    def __ne__(*args):
        """__ne__(self, PySwigIterator x) -> bool"""
        return _gnuradio_swig_python.PySwigIterator___ne__(*args)

    def __iadd__(*args):
        """__iadd__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_python.PySwigIterator___iadd__(*args)

    def __isub__(*args):
        """__isub__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_python.PySwigIterator___isub__(*args)

    def __add__(*args):
        """__add__(self, ptrdiff_t n) -> PySwigIterator"""
        return _gnuradio_swig_python.PySwigIterator___add__(*args)

    def __sub__(*args):
        """
        __sub__(self, ptrdiff_t n) -> PySwigIterator
        __sub__(self, PySwigIterator x) -> ptrdiff_t
        """
        return _gnuradio_swig_python.PySwigIterator___sub__(*args)

    def __iter__(self): return self
PySwigIterator_swigregister = _gnuradio_swig_python.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

sizeof_char = _gnuradio_swig_python.sizeof_char
sizeof_short = _gnuradio_swig_python.sizeof_short
sizeof_int = _gnuradio_swig_python.sizeof_int
sizeof_float = _gnuradio_swig_python.sizeof_float
sizeof_double = _gnuradio_swig_python.sizeof_double
sizeof_gr_complex = _gnuradio_swig_python.sizeof_gr_complex
class gr_io_signature_sptr(object):
    """Proxy of C++ gr_io_signature_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 __init__(self, *args): 
        """
        __init__(self) -> gr_io_signature_sptr
        __init__(self, gr_io_signature p) -> gr_io_signature_sptr
        """
        this = _gnuradio_swig_python.new_gr_io_signature_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_io_signature"""
        return _gnuradio_swig_python.gr_io_signature_sptr___deref__(*args)

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

    def max_streams(*args):
        """max_streams(self) -> int"""
        return _gnuradio_swig_python.gr_io_signature_sptr_max_streams(*args)

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

gr_io_signature_sptr_swigregister = _gnuradio_swig_python.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, size_t sizeof_stream_item) -> gr_io_signature_sptr"""
  return _gnuradio_swig_python.io_signature(*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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_io_signature
    __del__ = lambda self : None;
    def min_streams(*args):
        """min_streams(self) -> int"""
        return _gnuradio_swig_python.gr_io_signature_min_streams(*args)

    def max_streams(*args):
        """max_streams(self) -> int"""
        return _gnuradio_swig_python.gr_io_signature_max_streams(*args)

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

gr_io_signature_swigregister = _gnuradio_swig_python.gr_io_signature_swigregister
gr_io_signature_swigregister(gr_io_signature)

class gr_buffer_sptr(object):
    """Proxy of C++ gr_buffer_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 __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_sptr
        __init__(self,  p) -> gr_buffer_sptr
        """
        this = _gnuradio_swig_python.new_gr_buffer_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_buffer_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_buffer_sptr
    __del__ = lambda self : None;
gr_buffer_sptr_swigregister = _gnuradio_swig_python.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_python.buffer(*args)
class gr_buffer_reader_sptr(object):
    """Proxy of C++ gr_buffer_reader_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 __init__(self, *args): 
        """
        __init__(self) -> gr_buffer_reader_sptr
        __init__(self,  p) -> gr_buffer_reader_sptr
        """
        this = _gnuradio_swig_python.new_gr_buffer_reader_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_buffer_reader_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_buffer_reader_sptr
    __del__ = lambda self : None;
gr_buffer_reader_sptr_swigregister = _gnuradio_swig_python.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_python.buffer_add_reader(*args)

def buffer_ncurrently_allocated(*args):
  """buffer_ncurrently_allocated() -> long"""
  return _gnuradio_swig_python.buffer_ncurrently_allocated(*args)

def buffer_reader_ncurrently_allocated(*args):
  """buffer_reader_ncurrently_allocated() -> long"""
  return _gnuradio_swig_python.buffer_reader_ncurrently_allocated(*args)
class gr_block_sptr(object):
    """Proxy of C++ 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 __init__(self, *args): 
        """
        __init__(self) -> gr_block_sptr
        __init__(self, gr_block p) -> gr_block_sptr
        """
        this = _gnuradio_swig_python.new_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_block"""
        return _gnuradio_swig_python.gr_block_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_block_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_block_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_block_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_block_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_block_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_block_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_block_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_block_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_detail(*args)

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

gr_block_sptr_swigregister = _gnuradio_swig_python.gr_block_sptr_swigregister
gr_block_sptr_swigregister(gr_block_sptr)

class x_vector_gr_block_sptr(object):
    """Proxy of C++ x_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(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr___nonzero__(*args)

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

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

    def __getslice__(*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_python.x_vector_gr_block_sptr___getslice__(*args)

    def __setslice__(*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_python.x_vector_gr_block_sptr___setslice__(*args)

    def __delslice__(*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_python.x_vector_gr_block_sptr___delslice__(*args)

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

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

    def __setitem__(*args):
        """
        __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_python.x_vector_gr_block_sptr___setitem__(*args)

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

    def empty(*args):
        """empty(self) -> bool"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_empty(*args)

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

    def clear(*args):
        """clear(self)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_clear(*args)

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

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

    def begin(*args):
        """
        begin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        begin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_begin(*args)

    def end(*args):
        """
        end(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::iterator
        end(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_iterator
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::reverse_iterator
        rbegin(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::reverse_iterator
        rend(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::const_reverse_iterator
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_pop_back(*args)

    def erase(*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_python.x_vector_gr_block_sptr_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> x_vector_gr_block_sptr
        __init__(self, x_vector_gr_block_sptr ?) -> 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_python.new_x_vector_gr_block_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_push_back(*args)

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

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

    def assign(*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_python.x_vector_gr_block_sptr_assign(*args)

    def resize(*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_python.x_vector_gr_block_sptr_resize(*args)

    def insert(*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_python.x_vector_gr_block_sptr_insert(*args)

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

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

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

class gr_block(object):
    """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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_block
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_block_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_block_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_block_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_block_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_block_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_block_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_block_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_block_detail(*args)

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

gr_block_swigregister = _gnuradio_swig_python.gr_block_swigregister
gr_block_swigregister(gr_block)


def block_ncurrently_allocated(*args):
  """block_ncurrently_allocated() -> long"""
  return _gnuradio_swig_python.block_ncurrently_allocated(*args)
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++ gr_block_detail_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 __init__(self, *args): 
        """
        __init__(self) -> gr_block_detail_sptr
        __init__(self,  p) -> gr_block_detail_sptr
        """
        this = _gnuradio_swig_python.new_gr_block_detail_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_block_detail_sptr___deref__(*args)

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

    def noutputs(*args):
        """noutputs(self) -> int"""
        return _gnuradio_swig_python.gr_block_detail_sptr_noutputs(*args)

    def sink_p(*args):
        """sink_p(self) -> bool"""
        return _gnuradio_swig_python.gr_block_detail_sptr_sink_p(*args)

    def source_p(*args):
        """source_p(self) -> bool"""
        return _gnuradio_swig_python.gr_block_detail_sptr_source_p(*args)

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

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

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

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

gr_block_detail_sptr_swigregister = _gnuradio_swig_python.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_python.block_detail(*args)

def block_detail_ncurrently_allocated(*args):
  """block_detail_ncurrently_allocated() -> long"""
  return _gnuradio_swig_python.block_detail_ncurrently_allocated(*args)
class gr_single_threaded_scheduler_sptr(object):
    """Proxy of C++ gr_single_threaded_scheduler_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 __init__(self, *args): 
        """
        __init__(self) -> gr_single_threaded_scheduler_sptr
        __init__(self,  p) -> gr_single_threaded_scheduler_sptr
        """
        this = _gnuradio_swig_python.new_gr_single_threaded_scheduler_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_single_threaded_scheduler_sptr___deref__(*args)

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

gr_single_threaded_scheduler_sptr_swigregister = _gnuradio_swig_python.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_python.single_threaded_scheduler(*args)

def sts_pyrun(*args):
  """sts_pyrun(gr_single_threaded_scheduler_sptr s)"""
  return _gnuradio_swig_python.sts_pyrun(*args)
class gr_message_sptr(object):
    """Proxy of C++ gr_message_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 __init__(self, *args): 
        """
        __init__(self) -> gr_message_sptr
        __init__(self, gr_message p) -> gr_message_sptr
        """
        this = _gnuradio_swig_python.new_gr_message_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_message"""
        return _gnuradio_swig_python.gr_message_sptr___deref__(*args)

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

    def arg1(*args):
        """arg1(self) -> double"""
        return _gnuradio_swig_python.gr_message_sptr_arg1(*args)

    def arg2(*args):
        """arg2(self) -> double"""
        return _gnuradio_swig_python.gr_message_sptr_arg2(*args)

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

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

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

    def length(*args):
        """length(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_sptr_length(*args)

    def to_string(*args):
        """to_string(self) -> string"""
        return _gnuradio_swig_python.gr_message_sptr_to_string(*args)

gr_message_sptr_swigregister = _gnuradio_swig_python.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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_message
    __del__ = lambda self : None;
    def type(*args):
        """type(self) -> long"""
        return _gnuradio_swig_python.gr_message_type(*args)

    def arg1(*args):
        """arg1(self) -> double"""
        return _gnuradio_swig_python.gr_message_arg1(*args)

    def arg2(*args):
        """arg2(self) -> double"""
        return _gnuradio_swig_python.gr_message_arg2(*args)

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

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

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

    def length(*args):
        """length(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_length(*args)

    def to_string(*args):
        """to_string(self) -> string"""
        return _gnuradio_swig_python.gr_message_to_string(*args)

gr_message_swigregister = _gnuradio_swig_python.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_python.message_from_string(*args)

def message(*args):
  """
    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_python.message(*args)


def message_ncurrently_allocated(*args):
  """message_ncurrently_allocated() -> long"""
  return _gnuradio_swig_python.message_ncurrently_allocated(*args)
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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_msg_handler
    __del__ = lambda self : None;
    def handle(*args):
        """handle(self, gr_message_sptr msg)"""
        return _gnuradio_swig_python.gr_msg_handler_handle(*args)

gr_msg_handler_swigregister = _gnuradio_swig_python.gr_msg_handler_swigregister
gr_msg_handler_swigregister(gr_msg_handler)

class gr_msg_queue_sptr(object):
    """Proxy of C++ gr_msg_queue_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 __init__(self, *args): 
        """
        __init__(self) -> gr_msg_queue_sptr
        __init__(self,  p) -> gr_msg_queue_sptr
        """
        this = _gnuradio_swig_python.new_gr_msg_queue_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_msg_queue_sptr___deref__(*args)

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

    def empty_p(*args):
        """empty_p(self) -> bool"""
        return _gnuradio_swig_python.gr_msg_queue_sptr_empty_p(*args)

    def full_p(*args):
        """full_p(self) -> bool"""
        return _gnuradio_swig_python.gr_msg_queue_sptr_full_p(*args)

    def count(*args):
        """count(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_msg_queue_sptr_count(*args)

    def flush(*args):
        """flush(self)"""
        return _gnuradio_swig_python.gr_msg_queue_sptr_flush(*args)

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

gr_msg_queue_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_dispatcher_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 __init__(self, *args): 
        """
        __init__(self) -> gr_dispatcher_sptr
        __init__(self, gr_dispatcher p) -> gr_dispatcher_sptr
        """
        this = _gnuradio_swig_python.new_gr_dispatcher_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> gr_dispatcher"""
        return _gnuradio_swig_python.gr_dispatcher_sptr___deref__(*args)

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

gr_dispatcher_sptr_swigregister = _gnuradio_swig_python.gr_dispatcher_sptr_swigregister
gr_dispatcher_sptr_swigregister(gr_dispatcher_sptr)

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


def dispatcher(*args):
  """dispatcher() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_python.dispatcher(*args)

def dispatcher_singleton(*args):
  """dispatcher_singleton() -> gr_dispatcher_sptr"""
  return _gnuradio_swig_python.dispatcher_singleton(*args)
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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_dispatcher
    __del__ = lambda self : None;
    def loop(*args):
        """
        loop(self, double timeout=10)
        loop(self)
        """
        return _gnuradio_swig_python.gr_dispatcher_loop(*args)

gr_dispatcher_swigregister = _gnuradio_swig_python.gr_dispatcher_swigregister
gr_dispatcher_swigregister(gr_dispatcher)

class error_handler(object):
    """Proxy of C++ 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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    ERR_DEBUG = _gnuradio_swig_python.error_handler_ERR_DEBUG
    ERR_MESSAGE = _gnuradio_swig_python.error_handler_ERR_MESSAGE
    ERR_WARNING = _gnuradio_swig_python.error_handler_ERR_WARNING
    ERR_ERROR = _gnuradio_swig_python.error_handler_ERR_ERROR
    ERR_FATAL = _gnuradio_swig_python.error_handler_ERR_FATAL
    __swig_destroy__ = _gnuradio_swig_python.delete_error_handler
    __del__ = lambda self : None;
    def default_handler(*args):
        """default_handler() -> error_handler"""
        return _gnuradio_swig_python.error_handler_default_handler(*args)

    default_handler = staticmethod(default_handler)
    def silent_handler(*args):
        """silent_handler() -> error_handler"""
        return _gnuradio_swig_python.error_handler_silent_handler(*args)

    silent_handler = staticmethod(silent_handler)
    def has_default_handler(*args):
        """has_default_handler() -> bool"""
        return _gnuradio_swig_python.error_handler_has_default_handler(*args)

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

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

    def nerrors(*args):
        """nerrors(self) -> int"""
        return _gnuradio_swig_python.error_handler_nerrors(*args)

    def reset_counts(*args):
        """reset_counts(self)"""
        return _gnuradio_swig_python.error_handler_reset_counts(*args)

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

error_handler_swigregister = _gnuradio_swig_python.error_handler_swigregister
error_handler_swigregister(error_handler)

def error_handler_default_handler(*args):
  """error_handler_default_handler() -> error_handler"""
  return _gnuradio_swig_python.error_handler_default_handler(*args)

def error_handler_silent_handler(*args):
  """error_handler_silent_handler() -> error_handler"""
  return _gnuradio_swig_python.error_handler_silent_handler(*args)

def error_handler_has_default_handler(*args):
  """error_handler_has_default_handler() -> bool"""
  return _gnuradio_swig_python.error_handler_has_default_handler(*args)

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

class file_error_handler(object):
    """Proxy of C++ 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_python.new_file_error_handler(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_file_error_handler
    __del__ = lambda self : None;
file_error_handler_swigregister = _gnuradio_swig_python.file_error_handler_swigregister
file_error_handler_swigregister(file_error_handler)

RT_OK = _gnuradio_swig_python.RT_OK
RT_NOT_IMPLEMENTED = _gnuradio_swig_python.RT_NOT_IMPLEMENTED
RT_NO_PRIVS = _gnuradio_swig_python.RT_NO_PRIVS
RT_OTHER_ERROR = _gnuradio_swig_python.RT_OTHER_ERROR

def enable_realtime_scheduling(*args):
  """enable_realtime_scheduling() -> int"""
  return _gnuradio_swig_python.enable_realtime_scheduling(*args)
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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sync_block
    __del__ = lambda self : None;
gr_sync_block_swigregister = _gnuradio_swig_python.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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sync_decimator
    __del__ = lambda self : None;
gr_sync_decimator_swigregister = _gnuradio_swig_python.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): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sync_interpolator
    __del__ = lambda self : None;
gr_sync_interpolator_swigregister = _gnuradio_swig_python.gr_sync_interpolator_swigregister
gr_sync_interpolator_swigregister(gr_sync_interpolator)


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

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

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

def head(*args):
  """head(size_t sizeof_stream_item, int nitems) -> gr_block_sptr"""
  return _gnuradio_swig_python.head(*args)

def skiphead(*args):
  """skiphead(size_t sizeof_stream_item, int nitems) -> gr_block_sptr"""
  return _gnuradio_swig_python.skiphead(*args)
GR_CONST_WAVE = _gnuradio_swig_python.GR_CONST_WAVE
GR_SIN_WAVE = _gnuradio_swig_python.GR_SIN_WAVE
GR_COS_WAVE = _gnuradio_swig_python.GR_COS_WAVE
GR_UNIFORM = _gnuradio_swig_python.GR_UNIFORM
GR_GAUSSIAN = _gnuradio_swig_python.GR_GAUSSIAN
GR_LAPLACIAN = _gnuradio_swig_python.GR_LAPLACIAN
GR_IMPULSE = _gnuradio_swig_python.GR_IMPULSE
class gr_quadrature_demod_cf_sptr(object):
    """Proxy of C++ gr_quadrature_demod_cf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_quadrature_demod_cf_sptr
        __init__(self,  p) -> gr_quadrature_demod_cf_sptr
        """
        this = _gnuradio_swig_python.new_gr_quadrature_demod_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_quadrature_demod_cf_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_detail(*args)

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

gr_quadrature_demod_cf_sptr_swigregister = _gnuradio_swig_python.gr_quadrature_demod_cf_sptr_swigregister
gr_quadrature_demod_cf_sptr_swigregister(gr_quadrature_demod_cf_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_float_to_complex_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_float_to_complex_sptr_detail(*args)

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

gr_float_to_complex_sptr_swigregister = _gnuradio_swig_python.gr_float_to_complex_sptr_swigregister
gr_float_to_complex_sptr_swigregister(gr_float_to_complex_sptr)

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


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_check_counting_s_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_check_counting_s_sptr_detail(*args)

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

gr_check_counting_s_sptr_swigregister = _gnuradio_swig_python.gr_check_counting_s_sptr_swigregister
gr_check_counting_s_sptr_swigregister(gr_check_counting_s_sptr)


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_lfsr_32k_source_s_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_detail(*args)

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

gr_lfsr_32k_source_s_sptr_swigregister = _gnuradio_swig_python.gr_lfsr_32k_source_s_sptr_swigregister
gr_lfsr_32k_source_s_sptr_swigregister(gr_lfsr_32k_source_s_sptr)

def check_counting_s(*args):
  """
    check_counting_s(bool do_32bit=False) -> gr_check_counting_s_sptr
    check_counting_s() -> gr_check_counting_s_sptr
    """
  return _gnuradio_swig_python.check_counting_s(*args)


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


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

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

    def nright(*args):
        """nright(self) -> long"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_nright(*args)

    def runlength(*args):
        """runlength(self) -> long"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_runlength(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_detail(*args)

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

gr_check_lfsr_32k_s_sptr_swigregister = _gnuradio_swig_python.gr_check_lfsr_32k_s_sptr_swigregister
gr_check_lfsr_32k_s_sptr_swigregister(gr_check_lfsr_32k_s_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_stream_to_vector_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_stream_to_vector_sptr_detail(*args)

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

gr_stream_to_vector_sptr_swigregister = _gnuradio_swig_python.gr_stream_to_vector_sptr_swigregister
gr_stream_to_vector_sptr_swigregister(gr_stream_to_vector_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_to_stream_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_to_stream_sptr_detail(*args)

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

gr_vector_to_stream_sptr_swigregister = _gnuradio_swig_python.gr_vector_to_stream_sptr_swigregister
gr_vector_to_stream_sptr_swigregister(gr_vector_to_stream_sptr)


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


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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_keep_one_in_n_sptr_detail(*args)

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

gr_keep_one_in_n_sptr_swigregister = _gnuradio_swig_python.gr_keep_one_in_n_sptr_swigregister
gr_keep_one_in_n_sptr_swigregister(gr_keep_one_in_n_sptr)


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


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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fft_vcc_sptr_detail(*args)

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

gr_fft_vcc_sptr_swigregister = _gnuradio_swig_python.gr_fft_vcc_sptr_swigregister
gr_fft_vcc_sptr_swigregister(gr_fft_vcc_sptr)


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


def fft_vcc(*args):
  """fft_vcc(int fft_size, bool forward, __dummy_4__ window) -> gr_fft_vcc_sptr"""
  return _gnuradio_swig_python.fft_vcc(*args)
class gr_fft_vfc_sptr(object):
    """Proxy of C++ gr_fft_vfc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fft_vfc_sptr
        __init__(self,  p) -> gr_fft_vfc_sptr
        """
        this = _gnuradio_swig_python.new_gr_fft_vfc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr___deref__(*args)

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fft_vfc_sptr_detail(*args)

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

gr_fft_vfc_sptr_swigregister = _gnuradio_swig_python.gr_fft_vfc_sptr_swigregister
gr_fft_vfc_sptr_swigregister(gr_fft_vfc_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_float_to_short_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_float_to_short_sptr_detail(*args)

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

gr_float_to_short_sptr_swigregister = _gnuradio_swig_python.gr_float_to_short_sptr_swigregister
gr_float_to_short_sptr_swigregister(gr_float_to_short_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_float_to_char_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_float_to_char_sptr_detail(*args)

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

gr_float_to_char_sptr_swigregister = _gnuradio_swig_python.gr_float_to_char_sptr_swigregister
gr_float_to_char_sptr_swigregister(gr_float_to_char_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_float_to_uchar_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_float_to_uchar_sptr_detail(*args)

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

gr_float_to_uchar_sptr_swigregister = _gnuradio_swig_python.gr_float_to_uchar_sptr_swigregister
gr_float_to_uchar_sptr_swigregister(gr_float_to_uchar_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_short_to_float_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_short_to_float_sptr_detail(*args)

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

gr_short_to_float_sptr_swigregister = _gnuradio_swig_python.gr_short_to_float_sptr_swigregister
gr_short_to_float_sptr_swigregister(gr_short_to_float_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_char_to_float_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_char_to_float_sptr_detail(*args)

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

gr_char_to_float_sptr_swigregister = _gnuradio_swig_python.gr_char_to_float_sptr_swigregister
gr_char_to_float_sptr_swigregister(gr_char_to_float_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_uchar_to_float_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_uchar_to_float_sptr_detail(*args)

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

gr_uchar_to_float_sptr_swigregister = _gnuradio_swig_python.gr_uchar_to_float_sptr_swigregister
gr_uchar_to_float_sptr_swigregister(gr_uchar_to_float_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_frequency_modulator_fc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_detail(*args)

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

gr_frequency_modulator_fc_sptr_swigregister = _gnuradio_swig_python.gr_frequency_modulator_fc_sptr_swigregister
gr_frequency_modulator_fc_sptr_swigregister(gr_frequency_modulator_fc_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_phase_modulator_fc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_phase_modulator_fc_sptr_detail(*args)

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

gr_phase_modulator_fc_sptr_swigregister = _gnuradio_swig_python.gr_phase_modulator_fc_sptr_swigregister
gr_phase_modulator_fc_sptr_swigregister(gr_phase_modulator_fc_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_bytes_to_syms_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_bytes_to_syms_sptr_detail(*args)

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

gr_bytes_to_syms_sptr_swigregister = _gnuradio_swig_python.gr_bytes_to_syms_sptr_swigregister
gr_bytes_to_syms_sptr_swigregister(gr_bytes_to_syms_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_simple_correlator_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_simple_correlator_sptr_detail(*args)

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

gr_simple_correlator_sptr_swigregister = _gnuradio_swig_python.gr_simple_correlator_sptr_swigregister
gr_simple_correlator_sptr_swigregister(gr_simple_correlator_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_simple_framer_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_simple_framer_sptr_detail(*args)

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

gr_simple_framer_sptr_swigregister = _gnuradio_swig_python.gr_simple_framer_sptr_swigregister
gr_simple_framer_sptr_swigregister(gr_simple_framer_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_align_on_samplenumbers_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_detail(*args)

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

gr_align_on_samplenumbers_ss_sptr_swigregister = _gnuradio_swig_python.gr_align_on_samplenumbers_ss_sptr_swigregister
gr_align_on_samplenumbers_ss_sptr_swigregister(gr_align_on_samplenumbers_ss_sptr)


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_float_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_float_sptr_detail(*args)

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

gr_complex_to_float_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_float_sptr_swigregister
gr_complex_to_float_sptr_swigregister(gr_complex_to_float_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_real_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_real_sptr_detail(*args)

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

gr_complex_to_real_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_real_sptr_swigregister
gr_complex_to_real_sptr_swigregister(gr_complex_to_real_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_imag_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_imag_sptr_detail(*args)

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

gr_complex_to_imag_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_imag_sptr_swigregister
gr_complex_to_imag_sptr_swigregister(gr_complex_to_imag_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_mag_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_sptr_detail(*args)

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

gr_complex_to_mag_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_mag_sptr_swigregister
gr_complex_to_mag_sptr_swigregister(gr_complex_to_mag_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_mag_squared_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_detail(*args)

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

gr_complex_to_mag_squared_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_mag_squared_sptr_swigregister
gr_complex_to_mag_squared_sptr_swigregister(gr_complex_to_mag_squared_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_arg_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_arg_sptr_detail(*args)

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

gr_complex_to_arg_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_arg_sptr_swigregister
gr_complex_to_arg_sptr_swigregister(gr_complex_to_arg_sptr)

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


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_complex_to_interleaved_short_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_detail(*args)

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

gr_complex_to_interleaved_short_sptr_swigregister = _gnuradio_swig_python.gr_complex_to_interleaved_short_sptr_swigregister
gr_complex_to_interleaved_short_sptr_swigregister(gr_complex_to_interleaved_short_sptr)

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


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interleaved_short_to_complex_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_detail(*args)

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

gr_interleaved_short_to_complex_sptr_swigregister = _gnuradio_swig_python.gr_interleaved_short_to_complex_sptr_swigregister
gr_interleaved_short_to_complex_sptr_swigregister(gr_interleaved_short_to_complex_sptr)


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interleave_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interleave_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interleave_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interleave_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interleave_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interleave_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interleave_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interleave_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interleave_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interleave_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interleave_sptr_detail(*args)

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

gr_interleave_sptr_swigregister = _gnuradio_swig_python.gr_interleave_sptr_swigregister
gr_interleave_sptr_swigregister(gr_interleave_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_deinterleave_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_deinterleave_sptr_detail(*args)

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

gr_deinterleave_sptr_swigregister = _gnuradio_swig_python.gr_deinterleave_sptr_swigregister
gr_deinterleave_sptr_swigregister(gr_deinterleave_sptr)


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


def deinterleave(*args):
  """deinterleave(size_t itemsize) -> gr_deinterleave_sptr"""
  return _gnuradio_swig_python.deinterleave(*args)
class gr_simple_squelch_cc_sptr(object):
    """Proxy of C++ gr_simple_squelch_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_simple_squelch_cc_sptr
        __init__(self,  p) -> gr_simple_squelch_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_simple_squelch_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr___deref__(*args)

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

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

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

    def threshold(*args):
        """threshold(self) -> double"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_threshold(*args)

    def squelch_range(*args):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_squelch_range(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_simple_squelch_cc_sptr_detail(*args)

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

gr_simple_squelch_cc_sptr_swigregister = _gnuradio_swig_python.gr_simple_squelch_cc_sptr_swigregister
gr_simple_squelch_cc_sptr_swigregister(gr_simple_squelch_cc_sptr)


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_agc_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_agc_ff_sptr_detail(*args)

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

gr_agc_ff_sptr_swigregister = _gnuradio_swig_python.gr_agc_ff_sptr_swigregister
gr_agc_ff_sptr_swigregister(gr_agc_ff_sptr)

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


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

class gri_agc_ff(object):
    """Proxy of C++ gri_agc_ff class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float rate=1e-4, float reference=1.0, float gain=1.0, 
            float max_gain=0.0) -> gri_agc_ff
        __init__(self, float rate=1e-4, float reference=1.0, float gain=1.0) -> gri_agc_ff
        __init__(self, float rate=1e-4, float reference=1.0) -> gri_agc_ff
        __init__(self, float rate=1e-4) -> gri_agc_ff
        __init__(self) -> gri_agc_ff
        """
        this = _gnuradio_swig_python.new_gri_agc_ff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_gri_agc_ff
    __del__ = lambda self : None;
gri_agc_ff_swigregister = _gnuradio_swig_python.gri_agc_ff_swigregister
gri_agc_ff_swigregister(gri_agc_ff)

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_agc_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_detail(*args)

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

    def rate(*args):
        """rate(self) -> float"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_rate(*args)

    def reference(*args):
        """reference(self) -> float"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_reference(*args)

    def gain(*args):
        """gain(self) -> float"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_gain(*args)

    def max_gain(*args):
        """max_gain(self) -> float"""
        return _gnuradio_swig_python.gr_agc_cc_sptr_max_gain(*args)

gr_agc_cc_sptr_swigregister = _gnuradio_swig_python.gr_agc_cc_sptr_swigregister
gr_agc_cc_sptr_swigregister(gr_agc_cc_sptr)

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


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

class gri_agc_cc(object):
    """Proxy of C++ gri_agc_cc class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float rate=1e-4, float reference=1.0, float gain=1.0, 
            float max_gain=0.0) -> gri_agc_cc
        __init__(self, float rate=1e-4, float reference=1.0, float gain=1.0) -> gri_agc_cc
        __init__(self, float rate=1e-4, float reference=1.0) -> gri_agc_cc
        __init__(self, float rate=1e-4) -> gri_agc_cc
        __init__(self) -> gri_agc_cc
        """
        this = _gnuradio_swig_python.new_gri_agc_cc(*args)
        try: self.this.append(this)
        except: self.this = this
    def rate(*args):
        """rate(self) -> float"""
        return _gnuradio_swig_python.gri_agc_cc_rate(*args)

    def reference(*args):
        """reference(self) -> float"""
        return _gnuradio_swig_python.gri_agc_cc_reference(*args)

    def gain(*args):
        """gain(self) -> float"""
        return _gnuradio_swig_python.gri_agc_cc_gain(*args)

    def max_gain(*args):
        """max_gain(self) -> float"""
        return _gnuradio_swig_python.gri_agc_cc_max_gain(*args)

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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_agc2_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_agc2_ff_sptr_detail(*args)

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

gr_agc2_ff_sptr_swigregister = _gnuradio_swig_python.gr_agc2_ff_sptr_swigregister
gr_agc2_ff_sptr_swigregister(gr_agc2_ff_sptr)

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


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

class gri_agc2_ff(object):
    """Proxy of C++ gri_agc2_ff class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, 
            float gain=1.0, float max_gain=0.0) -> gri_agc2_ff
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, 
            float gain=1.0) -> gri_agc2_ff
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0) -> gri_agc2_ff
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2) -> gri_agc2_ff
        __init__(self, float attack_rate=1e-1) -> gri_agc2_ff
        __init__(self) -> gri_agc2_ff
        """
        this = _gnuradio_swig_python.new_gri_agc2_ff(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_gri_agc2_ff
    __del__ = lambda self : None;
gri_agc2_ff_swigregister = _gnuradio_swig_python.gri_agc2_ff_swigregister
gri_agc2_ff_swigregister(gri_agc2_ff)

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_agc2_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_detail(*args)

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

    def decay_rate(*args):
        """decay_rate(self) -> float"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_decay_rate(*args)

    def attack_rate(*args):
        """attack_rate(self) -> float"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_attack_rate(*args)

    def reference(*args):
        """reference(self) -> float"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_reference(*args)

    def gain(*args):
        """gain(self) -> float"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_gain(*args)

    def max_gain(*args):
        """max_gain(self) -> float"""
        return _gnuradio_swig_python.gr_agc2_cc_sptr_max_gain(*args)

gr_agc2_cc_sptr_swigregister = _gnuradio_swig_python.gr_agc2_cc_sptr_swigregister
gr_agc2_cc_sptr_swigregister(gr_agc2_cc_sptr)

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


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

class gri_agc2_cc(object):
    """Proxy of C++ gri_agc2_cc class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, 
            float gain=1.0, float max_gain=0.0) -> gri_agc2_cc
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0, 
            float gain=1.0) -> gri_agc2_cc
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2, float reference=1.0) -> gri_agc2_cc
        __init__(self, float attack_rate=1e-1, float decay_rate=1e-2) -> gri_agc2_cc
        __init__(self, float attack_rate=1e-1) -> gri_agc2_cc
        __init__(self) -> gri_agc2_cc
        """
        this = _gnuradio_swig_python.new_gri_agc2_cc(*args)
        try: self.this.append(this)
        except: self.this = this
    def decay_rate(*args):
        """decay_rate(self) -> float"""
        return _gnuradio_swig_python.gri_agc2_cc_decay_rate(*args)

    def attack_rate(*args):
        """attack_rate(self) -> float"""
        return _gnuradio_swig_python.gri_agc2_cc_attack_rate(*args)

    def reference(*args):
        """reference(self) -> float"""
        return _gnuradio_swig_python.gri_agc2_cc_reference(*args)

    def gain(*args):
        """gain(self) -> float"""
        return _gnuradio_swig_python.gri_agc2_cc_gain(*args)

    def max_gain(*args):
        """max_gain(self) -> float"""
        return _gnuradio_swig_python.gri_agc2_cc_max_gain(*args)

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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rms_cf_sptr_detail(*args)

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

gr_rms_cf_sptr_swigregister = _gnuradio_swig_python.gr_rms_cf_sptr_swigregister
gr_rms_cf_sptr_swigregister(gr_rms_cf_sptr)

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


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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rms_ff_sptr_detail(*args)

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

gr_rms_ff_sptr_swigregister = _gnuradio_swig_python.gr_rms_ff_sptr_swigregister
gr_rms_ff_sptr_swigregister(gr_rms_ff_sptr)

def rms_cf(*args):
  """
    rms_cf(double alpha=0.0001) -> gr_rms_cf_sptr
    rms_cf() -> gr_rms_cf_sptr
    """
  return _gnuradio_swig_python.rms_cf(*args)


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_nlog10_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_nlog10_ff_sptr_detail(*args)

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

gr_nlog10_ff_sptr_swigregister = _gnuradio_swig_python.gr_nlog10_ff_sptr_swigregister
gr_nlog10_ff_sptr_swigregister(gr_nlog10_ff_sptr)

def rms_ff(*args):
  """
    rms_ff(double alpha=0.0001) -> gr_rms_ff_sptr
    rms_ff() -> gr_rms_ff_sptr
    """
  return _gnuradio_swig_python.rms_ff(*args)


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

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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fake_channel_encoder_pp_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_detail(*args)

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

gr_fake_channel_encoder_pp_sptr_swigregister = _gnuradio_swig_python.gr_fake_channel_encoder_pp_sptr_swigregister
gr_fake_channel_encoder_pp_sptr_swigregister(gr_fake_channel_encoder_pp_sptr)

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


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fake_channel_decoder_pp_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_detail(*args)

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

gr_fake_channel_decoder_pp_sptr_swigregister = _gnuradio_swig_python.gr_fake_channel_decoder_pp_sptr_swigregister
gr_fake_channel_decoder_pp_sptr_swigregister(gr_fake_channel_decoder_pp_sptr)


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


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

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_throttle_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_throttle_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_throttle_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_throttle_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_throttle_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_throttle_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_throttle_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_throttle_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_throttle_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_throttle_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_throttle_sptr_detail(*args)

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

gr_throttle_sptr_swigregister = _gnuradio_swig_python.gr_throttle_sptr_swigregister
gr_throttle_sptr_swigregister(gr_throttle_sptr)


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


def throttle(*args):
  """throttle(size_t itemsize, double samples_per_sec) -> gr_throttle_sptr"""
  return _gnuradio_swig_python.throttle(*args)
class gr_stream_to_streams_sptr(object):
    """Proxy of C++ gr_stream_to_streams_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 __init__(self, *args): 
        """
        __init__(self) -> gr_stream_to_streams_sptr
        __init__(self,  p) -> gr_stream_to_streams_sptr
        """
        this = _gnuradio_swig_python.new_gr_stream_to_streams_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_stream_to_streams_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_stream_to_streams_sptr_set_detail(*args)

gr_stream_to_streams_sptr_swigregister = _gnuradio_swig_python.gr_stream_to_streams_sptr_swigregister
gr_stream_to_streams_sptr_swigregister(gr_stream_to_streams_sptr)


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


def stream_to_streams(*args):
  """stream_to_streams(size_t itemsize, size_t nstreams) -> gr_stream_to_streams_sptr"""
  return _gnuradio_swig_python.stream_to_streams(*args)
class gr_streams_to_stream_sptr(object):
    """Proxy of C++ gr_streams_to_stream_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 __init__(self, *args): 
        """
        __init__(self) -> gr_streams_to_stream_sptr
        __init__(self,  p) -> gr_streams_to_stream_sptr
        """
        this = _gnuradio_swig_python.new_gr_streams_to_stream_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_streams_to_stream_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_streams_to_stream_sptr_set_detail(*args)

gr_streams_to_stream_sptr_swigregister = _gnuradio_swig_python.gr_streams_to_stream_sptr_swigregister
gr_streams_to_stream_sptr_swigregister(gr_streams_to_stream_sptr)


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


def streams_to_stream(*args):
  """streams_to_stream(size_t itemsize, size_t nstreams) -> gr_streams_to_stream_sptr"""
  return _gnuradio_swig_python.streams_to_stream(*args)
class gr_streams_to_vector_sptr(object):
    """Proxy of C++ gr_streams_to_vector_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 __init__(self, *args): 
        """
        __init__(self) -> gr_streams_to_vector_sptr
        __init__(self,  p) -> gr_streams_to_vector_sptr
        """
        this = _gnuradio_swig_python.new_gr_streams_to_vector_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_streams_to_vector_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_streams_to_vector_sptr_set_detail(*args)

gr_streams_to_vector_sptr_swigregister = _gnuradio_swig_python.gr_streams_to_vector_sptr_swigregister
gr_streams_to_vector_sptr_swigregister(gr_streams_to_vector_sptr)


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


def streams_to_vector(*args):
  """streams_to_vector(size_t itemsize, size_t nstreams) -> gr_streams_to_vector_sptr"""
  return _gnuradio_swig_python.streams_to_vector(*args)
class gr_vector_to_streams_sptr(object):
    """Proxy of C++ gr_vector_to_streams_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_to_streams_sptr
        __init__(self,  p) -> gr_vector_to_streams_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_to_streams_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_to_streams_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_to_streams_sptr_set_detail(*args)

gr_vector_to_streams_sptr_swigregister = _gnuradio_swig_python.gr_vector_to_streams_sptr_swigregister
gr_vector_to_streams_sptr_swigregister(gr_vector_to_streams_sptr)


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


def vector_to_streams(*args):
  """vector_to_streams(size_t itemsize, size_t nstreams) -> gr_vector_to_streams_sptr"""
  return _gnuradio_swig_python.vector_to_streams(*args)
class gr_conjugate_cc_sptr(object):
    """Proxy of C++ gr_conjugate_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_conjugate_cc_sptr
        __init__(self,  p) -> gr_conjugate_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_conjugate_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_conjugate_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_conjugate_cc_sptr_set_detail(*args)

gr_conjugate_cc_sptr_swigregister = _gnuradio_swig_python.gr_conjugate_cc_sptr_swigregister
gr_conjugate_cc_sptr_swigregister(gr_conjugate_cc_sptr)


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


def conjugate_cc(*args):
  """conjugate_cc() -> gr_conjugate_cc_sptr"""
  return _gnuradio_swig_python.conjugate_cc(*args)
class gr_vco_f_sptr(object):
    """Proxy of C++ gr_vco_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vco_f_sptr
        __init__(self,  p) -> gr_vco_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_vco_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vco_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vco_f_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vco_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vco_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vco_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vco_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vco_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vco_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vco_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vco_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vco_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vco_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vco_f_sptr_set_detail(*args)

gr_vco_f_sptr_swigregister = _gnuradio_swig_python.gr_vco_f_sptr_swigregister
gr_vco_f_sptr_swigregister(gr_vco_f_sptr)


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


def vco_f(*args):
  """vco_f(double sampling_rate, double sensitivity, double amplitude) -> gr_vco_f_sptr"""
  return _gnuradio_swig_python.vco_f(*args)

def update_crc32(*args):
  """update_crc32(unsigned int crc, string buf) -> unsigned int"""
  return _gnuradio_swig_python.update_crc32(*args)

def crc32(*args):
  """crc32(string buf) -> unsigned int"""
  return _gnuradio_swig_python.crc32(*args)
class gr_threshold_ff_sptr(object):
    """Proxy of C++ gr_threshold_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_threshold_ff_sptr
        __init__(self,  p) -> gr_threshold_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_threshold_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_threshold_ff_sptr
    __del__ = lambda self : None;
    def lo(*args):
        """lo(self) -> float"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_lo(*args)

    def set_lo(*args):
        """set_lo(self, float lo)"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_set_lo(*args)

    def hi(*args):
        """hi(self) -> float"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_hi(*args)

    def set_hi(*args):
        """set_hi(self, float hi)"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_set_hi(*args)

    def last_state(*args):
        """last_state(self) -> float"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_last_state(*args)

    def set_last_state(*args):
        """set_last_state(self, float last_state)"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_set_last_state(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_threshold_ff_sptr_set_detail(*args)

gr_threshold_ff_sptr_swigregister = _gnuradio_swig_python.gr_threshold_ff_sptr_swigregister
gr_threshold_ff_sptr_swigregister(gr_threshold_ff_sptr)


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

class gr_clock_recovery_mm_ff_sptr(object):
    """Proxy of C++ gr_clock_recovery_mm_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_clock_recovery_mm_ff_sptr
        __init__(self,  p) -> gr_clock_recovery_mm_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_clock_recovery_mm_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_clock_recovery_mm_ff_sptr
    __del__ = lambda self : None;
    def mu(*args):
        """mu(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_mu(*args)

    def omega(*args):
        """omega(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_omega(*args)

    def gain_mu(*args):
        """gain_mu(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_gain_mu(*args)

    def gain_omega(*args):
        """gain_omega(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_gain_omega(*args)

    def set_gain_mu(*args):
        """set_gain_mu(self, float gain_mu)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_set_gain_mu(*args)

    def set_gain_omega(*args):
        """set_gain_omega(self, float gain_omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_set_gain_omega(*args)

    def set_mu(*args):
        """set_mu(self, float omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_set_mu(*args)

    def set_omega(*args):
        """set_omega(self, float omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_set_omega(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_set_detail(*args)

gr_clock_recovery_mm_ff_sptr_swigregister = _gnuradio_swig_python.gr_clock_recovery_mm_ff_sptr_swigregister
gr_clock_recovery_mm_ff_sptr_swigregister(gr_clock_recovery_mm_ff_sptr)

def threshold_ff(*args):
  """
    threshold_ff(float lo, float hi, float initial_state=0) -> gr_threshold_ff_sptr
    threshold_ff(float lo, float hi) -> gr_threshold_ff_sptr
    """
  return _gnuradio_swig_python.threshold_ff(*args)


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

class gr_clock_recovery_mm_cc_sptr(object):
    """Proxy of C++ gr_clock_recovery_mm_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_clock_recovery_mm_cc_sptr
        __init__(self,  p) -> gr_clock_recovery_mm_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_clock_recovery_mm_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_clock_recovery_mm_cc_sptr
    __del__ = lambda self : None;
    def mu(*args):
        """mu(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_mu(*args)

    def omega(*args):
        """omega(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_omega(*args)

    def gain_mu(*args):
        """gain_mu(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_gain_mu(*args)

    def gain_omega(*args):
        """gain_omega(self) -> float"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_gain_omega(*args)

    def set_gain_mu(*args):
        """set_gain_mu(self, float gain_mu)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_gain_mu(*args)

    def set_gain_omega(*args):
        """set_gain_omega(self, float gain_omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_gain_omega(*args)

    def set_mu(*args):
        """set_mu(self, float omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_mu(*args)

    def set_omega(*args):
        """set_omega(self, float omega)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_omega(*args)

    def set_verbose(*args):
        """set_verbose(self, bool verbose)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_verbose(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_set_detail(*args)

gr_clock_recovery_mm_cc_sptr_swigregister = _gnuradio_swig_python.gr_clock_recovery_mm_cc_sptr_swigregister
gr_clock_recovery_mm_cc_sptr_swigregister(gr_clock_recovery_mm_cc_sptr)

def clock_recovery_mm_ff(*args):
  """
    clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu, 
        float omega_relative_limit=0.001) -> gr_clock_recovery_mm_ff_sptr
    clock_recovery_mm_ff(float omega, float gain_omega, float mu, float gain_mu) -> gr_clock_recovery_mm_ff_sptr
    """
  return _gnuradio_swig_python.clock_recovery_mm_ff(*args)


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


def clock_recovery_mm_cc(*args):
  """
    clock_recovery_mm_cc(float omega, float gain_omega, float mu, float gain_mu, 
        float omega_relative_limit) -> gr_clock_recovery_mm_cc_sptr
    """
  return _gnuradio_swig_python.clock_recovery_mm_cc(*args)
class gr_dd_mpsk_sync_cc_sptr(object):
    """Proxy of C++ gr_dd_mpsk_sync_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_dd_mpsk_sync_cc_sptr
        __init__(self,  p) -> gr_dd_mpsk_sync_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_dd_mpsk_sync_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_dd_mpsk_sync_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_set_detail(*args)

gr_dd_mpsk_sync_cc_sptr_swigregister = _gnuradio_swig_python.gr_dd_mpsk_sync_cc_sptr_swigregister
gr_dd_mpsk_sync_cc_sptr_swigregister(gr_dd_mpsk_sync_cc_sptr)


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


def dd_mpsk_sync_cc(*args):
  """
    dd_mpsk_sync_cc(float alpha, float beta, float max_freq, float min_freq, 
        float ref_phase, float omega, float gain_omega, 
        float mu, float gain_mu) -> gr_dd_mpsk_sync_cc_sptr
    """
  return _gnuradio_swig_python.dd_mpsk_sync_cc(*args)
class gr_packet_sink_sptr(object):
    """Proxy of C++ gr_packet_sink_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 __init__(self, *args): 
        """
        __init__(self) -> gr_packet_sink_sptr
        __init__(self,  p) -> gr_packet_sink_sptr
        """
        this = _gnuradio_swig_python.new_gr_packet_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_packet_sink_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_packet_sink_sptr
    __del__ = lambda self : None;
    def carrier_sensed(*args):
        """carrier_sensed(self) -> bool"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_carrier_sensed(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_packet_sink_sptr_set_detail(*args)

gr_packet_sink_sptr_swigregister = _gnuradio_swig_python.gr_packet_sink_sptr_swigregister
gr_packet_sink_sptr_swigregister(gr_packet_sink_sptr)


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

class gr_lms_dfe_cc_sptr(object):
    """Proxy of C++ gr_lms_dfe_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_lms_dfe_cc_sptr
        __init__(self,  p) -> gr_lms_dfe_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_lms_dfe_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_lms_dfe_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_lms_dfe_cc_sptr_set_detail(*args)

gr_lms_dfe_cc_sptr_swigregister = _gnuradio_swig_python.gr_lms_dfe_cc_sptr_swigregister
gr_lms_dfe_cc_sptr_swigregister(gr_lms_dfe_cc_sptr)

def packet_sink(*args):
  """
    packet_sink(__dummy_0__ sync_vector, gr_msg_queue_sptr target_queue, 
        int threshold=-1) -> gr_packet_sink_sptr
    packet_sink(__dummy_0__ sync_vector, gr_msg_queue_sptr target_queue) -> gr_packet_sink_sptr
    """
  return _gnuradio_swig_python.packet_sink(*args)


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


def lms_dfe_cc(*args):
  """
    lms_dfe_cc(float lambda_ff, float lambda_fb, unsigned int num_fftaps, 
        unsigned int num_fbtaps) -> gr_lms_dfe_cc_sptr
    """
  return _gnuradio_swig_python.lms_dfe_cc(*args)
class gr_lms_dfe_ff_sptr(object):
    """Proxy of C++ gr_lms_dfe_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_lms_dfe_ff_sptr
        __init__(self,  p) -> gr_lms_dfe_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_lms_dfe_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_lms_dfe_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_lms_dfe_ff_sptr_set_detail(*args)

gr_lms_dfe_ff_sptr_swigregister = _gnuradio_swig_python.gr_lms_dfe_ff_sptr_swigregister
gr_lms_dfe_ff_sptr_swigregister(gr_lms_dfe_ff_sptr)


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


def lms_dfe_ff(*args):
  """
    lms_dfe_ff(float lambda_ff, float lambda_fb, unsigned int num_fftaps, 
        unsigned int num_fbtaps) -> gr_lms_dfe_ff_sptr
    """
  return _gnuradio_swig_python.lms_dfe_ff(*args)
class gr_pll_freqdet_cf_sptr(object):
    """Proxy of C++ gr_pll_freqdet_cf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pll_freqdet_cf_sptr
        __init__(self,  p) -> gr_pll_freqdet_cf_sptr
        """
        this = _gnuradio_swig_python.new_gr_pll_freqdet_cf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pll_freqdet_cf_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_set_detail(*args)

gr_pll_freqdet_cf_sptr_swigregister = _gnuradio_swig_python.gr_pll_freqdet_cf_sptr_swigregister
gr_pll_freqdet_cf_sptr_swigregister(gr_pll_freqdet_cf_sptr)


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


def pll_freqdet_cf(*args):
  """pll_freqdet_cf(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_freqdet_cf_sptr"""
  return _gnuradio_swig_python.pll_freqdet_cf(*args)
class gr_pll_refout_cc_sptr(object):
    """Proxy of C++ gr_pll_refout_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pll_refout_cc_sptr
        __init__(self,  p) -> gr_pll_refout_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_pll_refout_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pll_refout_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pll_refout_cc_sptr_set_detail(*args)

gr_pll_refout_cc_sptr_swigregister = _gnuradio_swig_python.gr_pll_refout_cc_sptr_swigregister
gr_pll_refout_cc_sptr_swigregister(gr_pll_refout_cc_sptr)


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


def pll_refout_cc(*args):
  """pll_refout_cc(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_refout_cc_sptr"""
  return _gnuradio_swig_python.pll_refout_cc(*args)
class gr_pll_carriertracking_cc_sptr(object):
    """Proxy of C++ gr_pll_carriertracking_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pll_carriertracking_cc_sptr
        __init__(self,  p) -> gr_pll_carriertracking_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_pll_carriertracking_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pll_carriertracking_cc_sptr
    __del__ = lambda self : None;
    def lock_detector(*args):
        """lock_detector(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_lock_detector(*args)

    def squelch_enable(*args):
        """squelch_enable(self, bool ?) -> bool"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_squelch_enable(*args)

    def set_lock_threshold(*args):
        """set_lock_threshold(self, float ?) -> float"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_set_lock_threshold(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_set_detail(*args)

gr_pll_carriertracking_cc_sptr_swigregister = _gnuradio_swig_python.gr_pll_carriertracking_cc_sptr_swigregister
gr_pll_carriertracking_cc_sptr_swigregister(gr_pll_carriertracking_cc_sptr)


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


def pll_carriertracking_cc(*args):
  """pll_carriertracking_cc(float alpha, float beta, float max_freq, float min_freq) -> gr_pll_carriertracking_cc_sptr"""
  return _gnuradio_swig_python.pll_carriertracking_cc(*args)
class gr_probe_avg_mag_sqrd_c_sptr(object):
    """Proxy of C++ gr_probe_avg_mag_sqrd_c_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 __init__(self, *args): 
        """
        __init__(self) -> gr_probe_avg_mag_sqrd_c_sptr
        __init__(self,  p) -> gr_probe_avg_mag_sqrd_c_sptr
        """
        this = _gnuradio_swig_python.new_gr_probe_avg_mag_sqrd_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_probe_avg_mag_sqrd_c_sptr
    __del__ = lambda self : None;
    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_unmuted(*args)

    def level(*args):
        """level(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_level(*args)

    def set_alpha(*args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_set_alpha(*args)

    def set_threshold(*args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_set_threshold(*args)

    def threshold(*args):
        """threshold(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_threshold(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_set_detail(*args)

gr_probe_avg_mag_sqrd_c_sptr_swigregister = _gnuradio_swig_python.gr_probe_avg_mag_sqrd_c_sptr_swigregister
gr_probe_avg_mag_sqrd_c_sptr_swigregister(gr_probe_avg_mag_sqrd_c_sptr)


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

class gr_probe_avg_mag_sqrd_f_sptr(object):
    """Proxy of C++ gr_probe_avg_mag_sqrd_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_probe_avg_mag_sqrd_f_sptr
        __init__(self,  p) -> gr_probe_avg_mag_sqrd_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_probe_avg_mag_sqrd_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_probe_avg_mag_sqrd_f_sptr
    __del__ = lambda self : None;
    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_unmuted(*args)

    def level(*args):
        """level(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_level(*args)

    def threshold(*args):
        """threshold(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_threshold(*args)

    def set_alpha(*args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_set_alpha(*args)

    def set_threshold(*args):
        """set_threshold(self, double decibels)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_set_threshold(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_set_detail(*args)

gr_probe_avg_mag_sqrd_f_sptr_swigregister = _gnuradio_swig_python.gr_probe_avg_mag_sqrd_f_sptr_swigregister
gr_probe_avg_mag_sqrd_f_sptr_swigregister(gr_probe_avg_mag_sqrd_f_sptr)

def probe_avg_mag_sqrd_c(*args):
  """
    probe_avg_mag_sqrd_c(double threshold_db, double alpha=0.0001) -> gr_probe_avg_mag_sqrd_c_sptr
    probe_avg_mag_sqrd_c(double threshold_db) -> gr_probe_avg_mag_sqrd_c_sptr
    """
  return _gnuradio_swig_python.probe_avg_mag_sqrd_c(*args)


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

class gr_probe_signal_f_sptr(object):
    """Proxy of C++ gr_probe_signal_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_probe_signal_f_sptr
        __init__(self,  p) -> gr_probe_signal_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_probe_signal_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_probe_signal_f_sptr
    __del__ = lambda self : None;
    def level(*args):
        """level(self) -> float"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_level(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_probe_signal_f_sptr_set_detail(*args)

gr_probe_signal_f_sptr_swigregister = _gnuradio_swig_python.gr_probe_signal_f_sptr_swigregister
gr_probe_signal_f_sptr_swigregister(gr_probe_signal_f_sptr)

def probe_avg_mag_sqrd_f(*args):
  """
    probe_avg_mag_sqrd_f(double threshold_db, double alpha=0.0001) -> gr_probe_avg_mag_sqrd_f_sptr
    probe_avg_mag_sqrd_f(double threshold_db) -> gr_probe_avg_mag_sqrd_f_sptr
    """
  return _gnuradio_swig_python.probe_avg_mag_sqrd_f(*args)


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


def probe_signal_f(*args):
  """probe_signal_f() -> gr_probe_signal_f_sptr"""
  return _gnuradio_swig_python.probe_signal_f(*args)
class gr_costas_loop_cc_sptr(object):
    """Proxy of C++ gr_costas_loop_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_costas_loop_cc_sptr
        __init__(self,  p) -> gr_costas_loop_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_costas_loop_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_costas_loop_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_costas_loop_cc_sptr_set_detail(*args)

gr_costas_loop_cc_sptr_swigregister = _gnuradio_swig_python.gr_costas_loop_cc_sptr_swigregister
gr_costas_loop_cc_sptr_swigregister(gr_costas_loop_cc_sptr)


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


def costas_loop_cc(*args):
  """
    costas_loop_cc(float alpha, float beta, float max_freq, float min_freq, 
        int order) -> gr_costas_loop_cc_sptr
    """
  return _gnuradio_swig_python.costas_loop_cc(*args)
class gr_pa_2x2_phase_combiner_sptr(object):
    """Proxy of C++ gr_pa_2x2_phase_combiner_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pa_2x2_phase_combiner_sptr
        __init__(self,  p) -> gr_pa_2x2_phase_combiner_sptr
        """
        this = _gnuradio_swig_python.new_gr_pa_2x2_phase_combiner_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pa_2x2_phase_combiner_sptr
    __del__ = lambda self : None;
    def theta(*args):
        """theta(self) -> float"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_theta(*args)

    def set_theta(*args):
        """set_theta(self, float theta)"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_set_theta(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_set_detail(*args)

gr_pa_2x2_phase_combiner_sptr_swigregister = _gnuradio_swig_python.gr_pa_2x2_phase_combiner_sptr_swigregister
gr_pa_2x2_phase_combiner_sptr_swigregister(gr_pa_2x2_phase_combiner_sptr)


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


def pa_2x2_phase_combiner(*args):
  """pa_2x2_phase_combiner() -> gr_pa_2x2_phase_combiner_sptr"""
  return _gnuradio_swig_python.pa_2x2_phase_combiner(*args)
class gr_kludge_copy_sptr(object):
    """Proxy of C++ gr_kludge_copy_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 __init__(self, *args): 
        """
        __init__(self) -> gr_kludge_copy_sptr
        __init__(self,  p) -> gr_kludge_copy_sptr
        """
        this = _gnuradio_swig_python.new_gr_kludge_copy_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_kludge_copy_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_kludge_copy_sptr_set_detail(*args)

gr_kludge_copy_sptr_swigregister = _gnuradio_swig_python.gr_kludge_copy_sptr_swigregister
gr_kludge_copy_sptr_swigregister(gr_kludge_copy_sptr)


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


def kludge_copy(*args):
  """kludge_copy(size_t itemsize) -> gr_kludge_copy_sptr"""
  return _gnuradio_swig_python.kludge_copy(*args)
class gr_prefs(object):
    """Proxy of C++ gr_prefs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def singleton(*args):
        """singleton() -> gr_prefs"""
        return _gnuradio_swig_python.gr_prefs_singleton(*args)

    singleton = staticmethod(singleton)
    def set_singleton(*args):
        """set_singleton(gr_prefs p)"""
        return _gnuradio_swig_python.gr_prefs_set_singleton(*args)

    set_singleton = staticmethod(set_singleton)
    __swig_destroy__ = _gnuradio_swig_python.delete_gr_prefs
    __del__ = lambda self : None;
    def has_section(*args):
        """has_section(self, string section) -> bool"""
        return _gnuradio_swig_python.gr_prefs_has_section(*args)

    def has_option(*args):
        """has_option(self, string section, string option) -> bool"""
        return _gnuradio_swig_python.gr_prefs_has_option(*args)

    def get_string(*args):
        """get_string(self, string section, string option, string default_val) -> string"""
        return _gnuradio_swig_python.gr_prefs_get_string(*args)

    def get_bool(*args):
        """get_bool(self, string section, string option, bool default_val) -> bool"""
        return _gnuradio_swig_python.gr_prefs_get_bool(*args)

    def get_long(*args):
        """get_long(self, string section, string option, long default_val) -> long"""
        return _gnuradio_swig_python.gr_prefs_get_long(*args)

    def get_double(*args):
        """get_double(self, string section, string option, double default_val) -> double"""
        return _gnuradio_swig_python.gr_prefs_get_double(*args)

    def __init__(self, *args): 
        """__init__(self) -> gr_prefs"""
        if self.__class__ == gr_prefs:
            args = (None,) + args
        else:
            args = (self,) + args
        this = _gnuradio_swig_python.new_gr_prefs(*args)
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_python.disown_gr_prefs(self)
        return weakref_proxy(self)
gr_prefs_swigregister = _gnuradio_swig_python.gr_prefs_swigregister
gr_prefs_swigregister(gr_prefs)

def gr_prefs_singleton(*args):
  """gr_prefs_singleton() -> gr_prefs"""
  return _gnuradio_swig_python.gr_prefs_singleton(*args)

def gr_prefs_set_singleton(*args):
  """gr_prefs_set_singleton(gr_prefs p)"""
  return _gnuradio_swig_python.gr_prefs_set_singleton(*args)


def prefix(*args):
  """prefix() -> string"""
  return _gnuradio_swig_python.prefix(*args)
CONSUME_NOUTPUT_ITEMS = _gnuradio_swig_python.CONSUME_NOUTPUT_ITEMS
CONSUME_NOUTPUT_ITEMS_LIMIT_MAX = _gnuradio_swig_python.CONSUME_NOUTPUT_ITEMS_LIMIT_MAX
CONSUME_NOUTPUT_ITEMS_LIMIT_MIN = _gnuradio_swig_python.CONSUME_NOUTPUT_ITEMS_LIMIT_MIN
CONSUME_ALL_AVAILABLE = _gnuradio_swig_python.CONSUME_ALL_AVAILABLE
CONSUME_ALL_AVAILABLE_LIMIT_MAX = _gnuradio_swig_python.CONSUME_ALL_AVAILABLE_LIMIT_MAX
CONSUME_ZERO = _gnuradio_swig_python.CONSUME_ZERO
CONSUME_ONE = _gnuradio_swig_python.CONSUME_ONE
CONSUME_MINUS_ONE = _gnuradio_swig_python.CONSUME_MINUS_ONE
PRODUCE_NOUTPUT_ITEMS = _gnuradio_swig_python.PRODUCE_NOUTPUT_ITEMS
PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX = _gnuradio_swig_python.PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX
PRODUCE_ZERO = _gnuradio_swig_python.PRODUCE_ZERO
PRODUCE_ONE = _gnuradio_swig_python.PRODUCE_ONE
PRODUCE_MINUS_ONE = _gnuradio_swig_python.PRODUCE_MINUS_ONE
class gr_test_sptr(object):
    """Proxy of C++ gr_test_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 __init__(self, *args): 
        """
        __init__(self) -> gr_test_sptr
        __init__(self,  p) -> gr_test_sptr
        """
        this = _gnuradio_swig_python.new_gr_test_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_test_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_test_sptr
    __del__ = lambda self : None;
    def forecast(*args):
        """forecast(self, int noutput_items, gr_vector_int ninput_items_required)"""
        return _gnuradio_swig_python.gr_test_sptr_forecast(*args)

    def set_check_topology(*args):
        """set_check_topology(self, bool check_topology)"""
        return _gnuradio_swig_python.gr_test_sptr_set_check_topology(*args)

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

    def fixed_rate_ninput_to_noutput(*args):
        """fixed_rate_ninput_to_noutput(self, int ninput) -> int"""
        return _gnuradio_swig_python.gr_test_sptr_fixed_rate_ninput_to_noutput(*args)

    def fixed_rate_noutput_to_ninput(*args):
        """fixed_rate_noutput_to_ninput(self, int noutput) -> int"""
        return _gnuradio_swig_python.gr_test_sptr_fixed_rate_noutput_to_ninput(*args)

    def set_fixed_rate_public(*args):
        """set_fixed_rate_public(self, bool fixed_rate)"""
        return _gnuradio_swig_python.gr_test_sptr_set_fixed_rate_public(*args)

    def set_consume_type(*args):
        """set_consume_type(self, gr_consume_type_t cons_type)"""
        return _gnuradio_swig_python.gr_test_sptr_set_consume_type(*args)

    def set_consume_limit(*args):
        """set_consume_limit(self, unsigned int limit)"""
        return _gnuradio_swig_python.gr_test_sptr_set_consume_limit(*args)

    def set_produce_type(*args):
        """set_produce_type(self, gr_produce_type_t prod_type)"""
        return _gnuradio_swig_python.gr_test_sptr_set_produce_type(*args)

    def set_produce_limit(*args):
        """set_produce_limit(self, unsigned int limit)"""
        return _gnuradio_swig_python.gr_test_sptr_set_produce_limit(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_test_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_test_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_test_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_test_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_test_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_test_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_test_sptr_relative_rate(*args)

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_test_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_test_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_test_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_test_sptr_set_detail(*args)

gr_test_sptr_swigregister = _gnuradio_swig_python.gr_test_sptr_swigregister
gr_test_sptr_swigregister(gr_test_sptr)


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

class gr_unpack_k_bits_bb_sptr(object):
    """Proxy of C++ gr_unpack_k_bits_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_unpack_k_bits_bb_sptr
        __init__(self,  p) -> gr_unpack_k_bits_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_unpack_k_bits_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_unpack_k_bits_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_set_detail(*args)

gr_unpack_k_bits_bb_sptr_swigregister = _gnuradio_swig_python.gr_unpack_k_bits_bb_sptr_swigregister
gr_unpack_k_bits_bb_sptr_swigregister(gr_unpack_k_bits_bb_sptr)

def test(*args):
  """
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1, 
        unsigned int output_multiple=1, 
        double relative_rate=1.0, bool fixed_rate=True, 
        gr_consume_type_t cons_type=CONSUME_NOUTPUT_ITEMS, 
        gr_produce_type_t prod_type=PRODUCE_NOUTPUT_ITEMS) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1, 
        unsigned int output_multiple=1, 
        double relative_rate=1.0, bool fixed_rate=True, 
        gr_consume_type_t cons_type=CONSUME_NOUTPUT_ITEMS) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1, 
        unsigned int output_multiple=1, 
        double relative_rate=1.0, bool fixed_rate=True) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1, 
        unsigned int output_multiple=1, 
        double relative_rate=1.0) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1, 
        unsigned int output_multiple=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1, unsigned int history=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1, 
        unsigned int sizeof_output_item=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1, int max_outputs=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1, 
        int min_outputs=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1, unsigned int sizeof_input_item=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1, 
        int max_inputs=1) -> gr_test_sptr
    test(string name=std::string("gr_test"), int min_inputs=1) -> gr_test_sptr
    test(string name=std::string("gr_test")) -> gr_test_sptr
    test() -> gr_test_sptr
    """
  return _gnuradio_swig_python.test(*args)


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


def unpack_k_bits_bb(*args):
  """unpack_k_bits_bb(int k) -> gr_unpack_k_bits_bb_sptr"""
  return _gnuradio_swig_python.unpack_k_bits_bb(*args)
class gr_correlate_access_code_bb_sptr(object):
    """Proxy of C++ gr_correlate_access_code_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_correlate_access_code_bb_sptr
        __init__(self,  p) -> gr_correlate_access_code_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_correlate_access_code_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_correlate_access_code_bb_sptr
    __del__ = lambda self : None;
    def set_access_code(*args):
        """set_access_code(self, string access_code) -> bool"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_set_access_code(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_set_detail(*args)

gr_correlate_access_code_bb_sptr_swigregister = _gnuradio_swig_python.gr_correlate_access_code_bb_sptr_swigregister
gr_correlate_access_code_bb_sptr_swigregister(gr_correlate_access_code_bb_sptr)


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


def correlate_access_code_bb(*args):
  """correlate_access_code_bb(string access_code, int threshold) -> gr_correlate_access_code_bb_sptr"""
  return _gnuradio_swig_python.correlate_access_code_bb(*args)
class gr_diff_phasor_cc_sptr(object):
    """Proxy of C++ gr_diff_phasor_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_diff_phasor_cc_sptr
        __init__(self,  p) -> gr_diff_phasor_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_diff_phasor_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_diff_phasor_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_diff_phasor_cc_sptr_set_detail(*args)

gr_diff_phasor_cc_sptr_swigregister = _gnuradio_swig_python.gr_diff_phasor_cc_sptr_swigregister
gr_diff_phasor_cc_sptr_swigregister(gr_diff_phasor_cc_sptr)


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


def diff_phasor_cc(*args):
  """diff_phasor_cc() -> gr_diff_phasor_cc_sptr"""
  return _gnuradio_swig_python.diff_phasor_cc(*args)
class gr_constellation_decoder_cb_sptr(object):
    """Proxy of C++ gr_constellation_decoder_cb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_constellation_decoder_cb_sptr
        __init__(self,  p) -> gr_constellation_decoder_cb_sptr
        """
        this = _gnuradio_swig_python.new_gr_constellation_decoder_cb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_constellation_decoder_cb_sptr
    __del__ = lambda self : None;
    def set_constellation(*args):
        """
        set_constellation(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> sym_position, 
            __dummy_0__ sym_value_out) -> int
        """
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_set_constellation(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_set_detail(*args)

gr_constellation_decoder_cb_sptr_swigregister = _gnuradio_swig_python.gr_constellation_decoder_cb_sptr_swigregister
gr_constellation_decoder_cb_sptr_swigregister(gr_constellation_decoder_cb_sptr)


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


def constellation_decoder_cb(*args):
  """
    constellation_decoder_cb(std::vector<(gr_complex,std::allocator<(gr_complex)>)> sym_position, 
        __dummy_0__ sym_value_out) -> gr_constellation_decoder_cb_sptr
    """
  return _gnuradio_swig_python.constellation_decoder_cb(*args)
class gr_binary_slicer_fb_sptr(object):
    """Proxy of C++ gr_binary_slicer_fb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_binary_slicer_fb_sptr
        __init__(self,  p) -> gr_binary_slicer_fb_sptr
        """
        this = _gnuradio_swig_python.new_gr_binary_slicer_fb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_binary_slicer_fb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_binary_slicer_fb_sptr_set_detail(*args)

gr_binary_slicer_fb_sptr_swigregister = _gnuradio_swig_python.gr_binary_slicer_fb_sptr_swigregister
gr_binary_slicer_fb_sptr_swigregister(gr_binary_slicer_fb_sptr)


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


def binary_slicer_fb(*args):
  """binary_slicer_fb() -> gr_binary_slicer_fb_sptr"""
  return _gnuradio_swig_python.binary_slicer_fb(*args)
class gr_diff_encoder_bb_sptr(object):
    """Proxy of C++ gr_diff_encoder_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_diff_encoder_bb_sptr
        __init__(self,  p) -> gr_diff_encoder_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_diff_encoder_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_diff_encoder_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_diff_encoder_bb_sptr_set_detail(*args)

gr_diff_encoder_bb_sptr_swigregister = _gnuradio_swig_python.gr_diff_encoder_bb_sptr_swigregister
gr_diff_encoder_bb_sptr_swigregister(gr_diff_encoder_bb_sptr)


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


def diff_encoder_bb(*args):
  """diff_encoder_bb(unsigned int modulus) -> gr_diff_encoder_bb_sptr"""
  return _gnuradio_swig_python.diff_encoder_bb(*args)
class gr_diff_decoder_bb_sptr(object):
    """Proxy of C++ gr_diff_decoder_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_diff_decoder_bb_sptr
        __init__(self,  p) -> gr_diff_decoder_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_diff_decoder_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_diff_decoder_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_diff_decoder_bb_sptr_set_detail(*args)

gr_diff_decoder_bb_sptr_swigregister = _gnuradio_swig_python.gr_diff_decoder_bb_sptr_swigregister
gr_diff_decoder_bb_sptr_swigregister(gr_diff_decoder_bb_sptr)


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


def diff_decoder_bb(*args):
  """diff_decoder_bb(unsigned int modulus) -> gr_diff_decoder_bb_sptr"""
  return _gnuradio_swig_python.diff_decoder_bb(*args)
class gr_framer_sink_1_sptr(object):
    """Proxy of C++ gr_framer_sink_1_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 __init__(self, *args): 
        """
        __init__(self) -> gr_framer_sink_1_sptr
        __init__(self,  p) -> gr_framer_sink_1_sptr
        """
        this = _gnuradio_swig_python.new_gr_framer_sink_1_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_framer_sink_1_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_framer_sink_1_sptr_set_detail(*args)

gr_framer_sink_1_sptr_swigregister = _gnuradio_swig_python.gr_framer_sink_1_sptr_swigregister
gr_framer_sink_1_sptr_swigregister(gr_framer_sink_1_sptr)


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


def framer_sink_1(*args):
  """framer_sink_1(gr_msg_queue_sptr target_queue) -> gr_framer_sink_1_sptr"""
  return _gnuradio_swig_python.framer_sink_1(*args)
class gr_map_bb_sptr(object):
    """Proxy of C++ gr_map_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_map_bb_sptr
        __init__(self,  p) -> gr_map_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_map_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_map_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_map_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_map_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_map_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_map_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_map_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_map_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_map_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_map_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_map_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_map_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_map_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_map_bb_sptr_set_detail(*args)

gr_map_bb_sptr_swigregister = _gnuradio_swig_python.gr_map_bb_sptr_swigregister
gr_map_bb_sptr_swigregister(gr_map_bb_sptr)


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


def map_bb(*args):
  """map_bb(__dummy_3__ map) -> gr_map_bb_sptr"""
  return _gnuradio_swig_python.map_bb(*args)
class feval_dd(object):
    """Proxy of C++ feval_dd class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> feval_dd"""
        if self.__class__ == feval_dd:
            args = (None,) + args
        else:
            args = (self,) + args
        this = _gnuradio_swig_python.new_feval_dd(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_feval_dd
    __del__ = lambda self : None;
    def eval(*args):
        """eval(self, double x) -> double"""
        return _gnuradio_swig_python.feval_dd_eval(*args)

    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_python.disown_feval_dd(self)
        return weakref_proxy(self)
feval_dd_swigregister = _gnuradio_swig_python.feval_dd_swigregister
feval_dd_swigregister(feval_dd)

class feval_cc(object):
    """Proxy of C++ feval_cc class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> feval_cc"""
        if self.__class__ == feval_cc:
            args = (None,) + args
        else:
            args = (self,) + args
        this = _gnuradio_swig_python.new_feval_cc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_feval_cc
    __del__ = lambda self : None;
    def eval(*args):
        """eval(self, gr_complex x) -> gr_complex"""
        return _gnuradio_swig_python.feval_cc_eval(*args)

    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_python.disown_feval_cc(self)
        return weakref_proxy(self)
feval_cc_swigregister = _gnuradio_swig_python.feval_cc_swigregister
feval_cc_swigregister(feval_cc)

class feval_ll(object):
    """Proxy of C++ feval_ll class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> feval_ll"""
        if self.__class__ == feval_ll:
            args = (None,) + args
        else:
            args = (self,) + args
        this = _gnuradio_swig_python.new_feval_ll(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_feval_ll
    __del__ = lambda self : None;
    def eval(*args):
        """eval(self, long x) -> long"""
        return _gnuradio_swig_python.feval_ll_eval(*args)

    def __disown__(self):
        self.this.disown()
        _gnuradio_swig_python.disown_feval_ll(self)
        return weakref_proxy(self)
feval_ll_swigregister = _gnuradio_swig_python.feval_ll_swigregister
feval_ll_swigregister(feval_ll)


def feval_dd_example(*args):
  """feval_dd_example(feval_dd f, double x) -> double"""
  return _gnuradio_swig_python.feval_dd_example(*args)

def feval_cc_example(*args):
  """feval_cc_example(feval_cc f, gr_complex x) -> gr_complex"""
  return _gnuradio_swig_python.feval_cc_example(*args)

def feval_ll_example(*args):
  """feval_ll_example(feval_ll f, long x) -> long"""
  return _gnuradio_swig_python.feval_ll_example(*args)
class gr_pwr_squelch_cc_sptr(object):
    """Proxy of C++ gr_pwr_squelch_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pwr_squelch_cc_sptr
        __init__(self,  p) -> gr_pwr_squelch_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_pwr_squelch_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pwr_squelch_cc_sptr
    __del__ = lambda self : None;
    def threshold(*args):
        """threshold(self) -> double"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_threshold(*args)

    def set_threshold(*args):
        """set_threshold(self, double db)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_set_threshold(*args)

    def set_alpha(*args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_set_alpha(*args)

    def ramp(*args):
        """ramp(self) -> int"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_ramp(*args)

    def set_ramp(*args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_set_ramp(*args)

    def gate(*args):
        """gate(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_gate(*args)

    def set_gate(*args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_set_gate(*args)

    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_unmuted(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_set_detail(*args)

gr_pwr_squelch_cc_sptr_swigregister = _gnuradio_swig_python.gr_pwr_squelch_cc_sptr_swigregister
gr_pwr_squelch_cc_sptr_swigregister(gr_pwr_squelch_cc_sptr)


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

class gr_squelch_base_cc(gr_block):
    """Proxy of C++ gr_squelch_base_cc class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def ramp(*args):
        """ramp(self) -> int"""
        return _gnuradio_swig_python.gr_squelch_base_cc_ramp(*args)

    def set_ramp(*args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_python.gr_squelch_base_cc_set_ramp(*args)

    def gate(*args):
        """gate(self) -> bool"""
        return _gnuradio_swig_python.gr_squelch_base_cc_gate(*args)

    def set_gate(*args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_python.gr_squelch_base_cc_set_gate(*args)

    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_squelch_base_cc_unmuted(*args)

    def squelch_range(*args):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_squelch_base_cc_squelch_range(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_squelch_base_cc
    __del__ = lambda self : None;
gr_squelch_base_cc_swigregister = _gnuradio_swig_python.gr_squelch_base_cc_swigregister
gr_squelch_base_cc_swigregister(gr_squelch_base_cc)

class gr_pwr_squelch_ff_sptr(object):
    """Proxy of C++ gr_pwr_squelch_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_pwr_squelch_ff_sptr
        __init__(self,  p) -> gr_pwr_squelch_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_pwr_squelch_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_pwr_squelch_ff_sptr
    __del__ = lambda self : None;
    def threshold(*args):
        """threshold(self) -> double"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_threshold(*args)

    def set_threshold(*args):
        """set_threshold(self, double db)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_set_threshold(*args)

    def set_alpha(*args):
        """set_alpha(self, double alpha)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_set_alpha(*args)

    def ramp(*args):
        """ramp(self) -> int"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_ramp(*args)

    def set_ramp(*args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_set_ramp(*args)

    def gate(*args):
        """gate(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_gate(*args)

    def set_gate(*args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_set_gate(*args)

    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_unmuted(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_set_detail(*args)

gr_pwr_squelch_ff_sptr_swigregister = _gnuradio_swig_python.gr_pwr_squelch_ff_sptr_swigregister
gr_pwr_squelch_ff_sptr_swigregister(gr_pwr_squelch_ff_sptr)

def pwr_squelch_cc(*args):
  """
    pwr_squelch_cc(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db, double alpha=0.0001, int ramp=0) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db, double alpha=0.0001) -> gr_pwr_squelch_cc_sptr
    pwr_squelch_cc(double db) -> gr_pwr_squelch_cc_sptr
    """
  return _gnuradio_swig_python.pwr_squelch_cc(*args)


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

class gr_squelch_base_ff(gr_block):
    """Proxy of C++ gr_squelch_base_ff class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def ramp(*args):
        """ramp(self) -> int"""
        return _gnuradio_swig_python.gr_squelch_base_ff_ramp(*args)

    def set_ramp(*args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_python.gr_squelch_base_ff_set_ramp(*args)

    def gate(*args):
        """gate(self) -> bool"""
        return _gnuradio_swig_python.gr_squelch_base_ff_gate(*args)

    def set_gate(*args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_python.gr_squelch_base_ff_set_gate(*args)

    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_squelch_base_ff_unmuted(*args)

    def squelch_range(*args):
        """squelch_range(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_squelch_base_ff_squelch_range(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_squelch_base_ff
    __del__ = lambda self : None;
gr_squelch_base_ff_swigregister = _gnuradio_swig_python.gr_squelch_base_ff_swigregister
gr_squelch_base_ff_swigregister(gr_squelch_base_ff)

class gr_ctcss_squelch_ff_sptr(object):
    """Proxy of C++ gr_ctcss_squelch_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_ctcss_squelch_ff_sptr
        __init__(self,  p) -> gr_ctcss_squelch_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_ctcss_squelch_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_ctcss_squelch_ff_sptr
    __del__ = lambda self : None;
    def level(*args):
        """level(self) -> float"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_level(*args)

    def set_level(*args):
        """set_level(self, float level)"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_set_level(*args)

    def len(*args):
        """len(self) -> int"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_len(*args)

    def ramp(*args):
        """ramp(self) -> int"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_ramp(*args)

    def set_ramp(*args):
        """set_ramp(self, int ramp)"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_set_ramp(*args)

    def gate(*args):
        """gate(self) -> bool"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_gate(*args)

    def set_gate(*args):
        """set_gate(self, bool gate)"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_set_gate(*args)

    def unmuted(*args):
        """unmuted(self) -> bool"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_unmuted(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_set_detail(*args)

gr_ctcss_squelch_ff_sptr_swigregister = _gnuradio_swig_python.gr_ctcss_squelch_ff_sptr_swigregister
gr_ctcss_squelch_ff_sptr_swigregister(gr_ctcss_squelch_ff_sptr)

def pwr_squelch_ff(*args):
  """
    pwr_squelch_ff(double db, double alpha=0.0001, int ramp=0, bool gate=False) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db, double alpha=0.0001, int ramp=0) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db, double alpha=0.0001) -> gr_pwr_squelch_ff_sptr
    pwr_squelch_ff(double db) -> gr_pwr_squelch_ff_sptr
    """
  return _gnuradio_swig_python.pwr_squelch_ff(*args)


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

class gr_feedforward_agc_cc_sptr(object):
    """Proxy of C++ gr_feedforward_agc_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_feedforward_agc_cc_sptr
        __init__(self,  p) -> gr_feedforward_agc_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_feedforward_agc_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_feedforward_agc_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_set_detail(*args)

gr_feedforward_agc_cc_sptr_swigregister = _gnuradio_swig_python.gr_feedforward_agc_cc_sptr_swigregister
gr_feedforward_agc_cc_sptr_swigregister(gr_feedforward_agc_cc_sptr)

def ctcss_squelch_ff(*args):
  """
    ctcss_squelch_ff(int rate, float freq, float level=0.01, int len=0, 
        int ramp=0, bool gate=False) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level=0.01, int len=0, 
        int ramp=0) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level=0.01, int len=0) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq, float level=0.01) -> gr_ctcss_squelch_ff_sptr
    ctcss_squelch_ff(int rate, float freq) -> gr_ctcss_squelch_ff_sptr
    """
  return _gnuradio_swig_python.ctcss_squelch_ff(*args)


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

class gr_add_cc_sptr(object):
    """Proxy of C++ gr_add_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_cc_sptr
        __init__(self,  p) -> gr_add_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_cc_sptr_detail(*args)

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

gr_add_cc_sptr_swigregister = _gnuradio_swig_python.gr_add_cc_sptr_swigregister
gr_add_cc_sptr_swigregister(gr_add_cc_sptr)

def feedforward_agc_cc(*args):
  """
    feedforward_agc_cc(int nsamples, float reference=1.0) -> gr_feedforward_agc_cc_sptr
    feedforward_agc_cc(int nsamples) -> gr_feedforward_agc_cc_sptr
    """
  return _gnuradio_swig_python.feedforward_agc_cc(*args)


def gr_add_cc_block(*args):
  """gr_add_cc_block(gr_add_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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(*args):
  """add_cc() -> gr_add_cc_sptr"""
  return _gnuradio_swig_python.add_cc(*args)
class gr_add_const_cc_sptr(object):
    """Proxy of C++ gr_add_const_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_cc_sptr
        __init__(self,  p) -> gr_add_const_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_cc_sptr_detail(*args)

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

gr_add_const_cc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_cc(*args)
class gr_add_const_ff_sptr(object):
    """Proxy of C++ gr_add_const_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_ff_sptr
        __init__(self,  p) -> gr_add_const_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_ff_sptr_detail(*args)

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

gr_add_const_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_ff(*args)
class gr_add_const_ii_sptr(object):
    """Proxy of C++ gr_add_const_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_ii_sptr
        __init__(self,  p) -> gr_add_const_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_ii_sptr_detail(*args)

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

gr_add_const_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_ii(*args)
class gr_add_const_sf_sptr(object):
    """Proxy of C++ gr_add_const_sf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_sf_sptr
        __init__(self,  p) -> gr_add_const_sf_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_sf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_sf_sptr_detail(*args)

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

gr_add_const_sf_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_sf(*args)
class gr_add_const_ss_sptr(object):
    """Proxy of C++ gr_add_const_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_ss_sptr
        __init__(self,  p) -> gr_add_const_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_ss_sptr_detail(*args)

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

gr_add_const_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_ss(*args)
class gr_add_const_vcc_sptr(object):
    """Proxy of C++ gr_add_const_vcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_vcc_sptr
        __init__(self,  p) -> gr_add_const_vcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_vcc_sptr_detail(*args)

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

gr_add_const_vcc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_vcc(*args)
class gr_add_const_vff_sptr(object):
    """Proxy of C++ gr_add_const_vff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_vff_sptr
        __init__(self,  p) -> gr_add_const_vff_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_vff_sptr_detail(*args)

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

gr_add_const_vff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_vff(*args)
class gr_add_const_vii_sptr(object):
    """Proxy of C++ gr_add_const_vii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_vii_sptr
        __init__(self,  p) -> gr_add_const_vii_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_vii_sptr_detail(*args)

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

gr_add_const_vii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_vii(*args)
class gr_add_const_vss_sptr(object):
    """Proxy of C++ gr_add_const_vss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_const_vss_sptr
        __init__(self,  p) -> gr_add_const_vss_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_const_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_const_vss_sptr_detail(*args)

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

gr_add_const_vss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_const_vss(*args)
class gr_add_ff_sptr(object):
    """Proxy of C++ gr_add_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_ff_sptr
        __init__(self,  p) -> gr_add_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_ff_sptr_detail(*args)

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

gr_add_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """add_ff() -> gr_add_ff_sptr"""
  return _gnuradio_swig_python.add_ff(*args)
class gr_add_ii_sptr(object):
    """Proxy of C++ gr_add_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_ii_sptr
        __init__(self,  p) -> gr_add_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_ii_sptr_detail(*args)

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

gr_add_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """add_ii() -> gr_add_ii_sptr"""
  return _gnuradio_swig_python.add_ii(*args)
class gr_add_ss_sptr(object):
    """Proxy of C++ gr_add_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_ss_sptr
        __init__(self,  p) -> gr_add_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_ss_sptr_detail(*args)

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

gr_add_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """add_ss() -> gr_add_ss_sptr"""
  return _gnuradio_swig_python.add_ss(*args)
class gr_add_vcc_sptr(object):
    """Proxy of C++ gr_add_vcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_vcc_sptr
        __init__(self,  p) -> gr_add_vcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_vcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_vcc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_vcc_sptr_detail(*args)

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

gr_add_vcc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_vcc(*args)
class gr_add_vff_sptr(object):
    """Proxy of C++ gr_add_vff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_vff_sptr
        __init__(self,  p) -> gr_add_vff_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_vff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_vff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_vff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_vff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_vff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_vff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_vff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_vff_sptr_detail(*args)

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

gr_add_vff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_vff(*args)
class gr_add_vii_sptr(object):
    """Proxy of C++ gr_add_vii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_vii_sptr
        __init__(self,  p) -> gr_add_vii_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_vii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_vii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_vii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_vii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_vii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_vii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_vii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_vii_sptr_detail(*args)

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

gr_add_vii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_vii(*args)
class gr_add_vss_sptr(object):
    """Proxy of C++ gr_add_vss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_add_vss_sptr
        __init__(self,  p) -> gr_add_vss_sptr
        """
        this = _gnuradio_swig_python.new_gr_add_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_add_vss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_add_vss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_add_vss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_add_vss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_add_vss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_add_vss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_add_vss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_add_vss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_add_vss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_add_vss_sptr_detail(*args)

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

gr_add_vss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.add_vss(*args)
class gr_chunks_to_symbols_bc_sptr(object):
    """Proxy of C++ gr_chunks_to_symbols_bc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_bc_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_bc_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_bc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bc_sptr_detail(*args)

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

gr_chunks_to_symbols_bc_sptr_swigregister = _gnuradio_swig_python.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_python.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++ gr_chunks_to_symbols_bf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_bf_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_bf_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_bf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr___deref__(*args)

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

    def symbol_table(*args):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_symbol_table(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_bf_sptr_detail(*args)

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

gr_chunks_to_symbols_bf_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_chunks_to_symbols_ic_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_ic_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_ic_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_ic_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_ic_sptr_detail(*args)

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

gr_chunks_to_symbols_ic_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_chunks_to_symbols_if_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_if_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_if_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_if_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr___deref__(*args)

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

    def symbol_table(*args):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_symbol_table(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_if_sptr_detail(*args)

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

gr_chunks_to_symbols_if_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_chunks_to_symbols_sc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_sc_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_sc_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_sc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sc_sptr_detail(*args)

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

gr_chunks_to_symbols_sc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_chunks_to_symbols_sf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_chunks_to_symbols_sf_sptr
        __init__(self,  p) -> gr_chunks_to_symbols_sf_sptr
        """
        this = _gnuradio_swig_python.new_gr_chunks_to_symbols_sf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr___deref__(*args)

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

    def symbol_table(*args):
        """symbol_table(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_symbol_table(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_chunks_to_symbols_sf_sptr_detail(*args)

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

gr_chunks_to_symbols_sf_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_divide_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_divide_cc_sptr
        __init__(self,  p) -> gr_divide_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_divide_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_divide_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_divide_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_divide_cc_sptr_detail(*args)

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

gr_divide_cc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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(*args):
  """divide_cc() -> gr_divide_cc_sptr"""
  return _gnuradio_swig_python.divide_cc(*args)
class gr_divide_ff_sptr(object):
    """Proxy of C++ gr_divide_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_divide_ff_sptr
        __init__(self,  p) -> gr_divide_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_divide_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_divide_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_divide_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_divide_ff_sptr_detail(*args)

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

gr_divide_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """divide_ff() -> gr_divide_ff_sptr"""
  return _gnuradio_swig_python.divide_ff(*args)
class gr_divide_ii_sptr(object):
    """Proxy of C++ gr_divide_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_divide_ii_sptr
        __init__(self,  p) -> gr_divide_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_divide_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_divide_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_divide_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_divide_ii_sptr_detail(*args)

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

gr_divide_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """divide_ii() -> gr_divide_ii_sptr"""
  return _gnuradio_swig_python.divide_ii(*args)
class gr_divide_ss_sptr(object):
    """Proxy of C++ gr_divide_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_divide_ss_sptr
        __init__(self,  p) -> gr_divide_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_divide_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_divide_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_divide_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_divide_ss_sptr_detail(*args)

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

gr_divide_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """divide_ss() -> gr_divide_ss_sptr"""
  return _gnuradio_swig_python.divide_ss(*args)
class gr_multiply_cc_sptr(object):
    """Proxy of C++ gr_multiply_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_cc_sptr
        __init__(self,  p) -> gr_multiply_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_cc_sptr_detail(*args)

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

gr_multiply_cc_sptr_swigregister = _gnuradio_swig_python.gr_multiply_cc_sptr_swigregister
gr_multiply_cc_sptr_swigregister(gr_multiply_cc_sptr)


def gr_multiply_cc_block(*args):
  """gr_multiply_cc_block(gr_multiply_cc_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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(*args):
  """multiply_cc() -> gr_multiply_cc_sptr"""
  return _gnuradio_swig_python.multiply_cc(*args)
class gr_multiply_const_cc_sptr(object):
    """Proxy of C++ gr_multiply_const_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_cc_sptr
        __init__(self,  p) -> gr_multiply_const_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_cc_sptr_detail(*args)

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

gr_multiply_const_cc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_cc(*args)
class gr_multiply_const_ff_sptr(object):
    """Proxy of C++ gr_multiply_const_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_ff_sptr
        __init__(self,  p) -> gr_multiply_const_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ff_sptr_detail(*args)

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

gr_multiply_const_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_ff(*args)
class gr_multiply_const_ii_sptr(object):
    """Proxy of C++ gr_multiply_const_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_ii_sptr
        __init__(self,  p) -> gr_multiply_const_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ii_sptr_detail(*args)

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

gr_multiply_const_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_ii(*args)
class gr_multiply_const_ss_sptr(object):
    """Proxy of C++ gr_multiply_const_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_ss_sptr
        __init__(self,  p) -> gr_multiply_const_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_ss_sptr_detail(*args)

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

gr_multiply_const_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_ss(*args)
class gr_multiply_const_vcc_sptr(object):
    """Proxy of C++ gr_multiply_const_vcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_vcc_sptr
        __init__(self,  p) -> gr_multiply_const_vcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr___deref__(*args)

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_const_vcc_sptr_set_detail(*args)

gr_multiply_const_vcc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_vcc(*args)
class gr_multiply_const_vff_sptr(object):
    """Proxy of C++ gr_multiply_const_vff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_vff_sptr
        __init__(self,  p) -> gr_multiply_const_vff_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_const_vff_sptr
    __del__ = lambda self : None;
    def k(*args):
        """k(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_k(*args)

    def set_k(*args):
        """set_k(self, __dummy_4__ k)"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_set_k(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_const_vff_sptr_set_detail(*args)

gr_multiply_const_vff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_vff(*args)
class gr_multiply_const_vii_sptr(object):
    """Proxy of C++ gr_multiply_const_vii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_vii_sptr
        __init__(self,  p) -> gr_multiply_const_vii_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_const_vii_sptr
    __del__ = lambda self : None;
    def k(*args):
        """k(self) -> __dummy_3__"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_k(*args)

    def set_k(*args):
        """set_k(self, __dummy_3__ k)"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_set_k(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_const_vii_sptr_set_detail(*args)

gr_multiply_const_vii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_vii(*args)
class gr_multiply_const_vss_sptr(object):
    """Proxy of C++ gr_multiply_const_vss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_const_vss_sptr
        __init__(self,  p) -> gr_multiply_const_vss_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_const_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_const_vss_sptr
    __del__ = lambda self : None;
    def k(*args):
        """k(self) -> __dummy_2__"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_k(*args)

    def set_k(*args):
        """set_k(self, __dummy_2__ k)"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_set_k(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_const_vss_sptr_set_detail(*args)

gr_multiply_const_vss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_const_vss(*args)
class gr_multiply_ff_sptr(object):
    """Proxy of C++ gr_multiply_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_ff_sptr
        __init__(self,  p) -> gr_multiply_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_ff_sptr_set_detail(*args)

gr_multiply_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """multiply_ff() -> gr_multiply_ff_sptr"""
  return _gnuradio_swig_python.multiply_ff(*args)
class gr_multiply_ii_sptr(object):
    """Proxy of C++ gr_multiply_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_ii_sptr
        __init__(self,  p) -> gr_multiply_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_ii_sptr_set_detail(*args)

gr_multiply_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """multiply_ii() -> gr_multiply_ii_sptr"""
  return _gnuradio_swig_python.multiply_ii(*args)
class gr_multiply_ss_sptr(object):
    """Proxy of C++ gr_multiply_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_ss_sptr
        __init__(self,  p) -> gr_multiply_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_multiply_ss_sptr_set_detail(*args)

gr_multiply_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """multiply_ss() -> gr_multiply_ss_sptr"""
  return _gnuradio_swig_python.multiply_ss(*args)
class gr_multiply_vcc_sptr(object):
    """Proxy of C++ gr_multiply_vcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_vcc_sptr
        __init__(self,  p) -> gr_multiply_vcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_vcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_vcc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_vcc_sptr_detail(*args)

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

gr_multiply_vcc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_vcc(*args)
class gr_multiply_vff_sptr(object):
    """Proxy of C++ gr_multiply_vff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_vff_sptr
        __init__(self,  p) -> gr_multiply_vff_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_vff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_vff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_vff_sptr_detail(*args)

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

gr_multiply_vff_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_vff(*args)
class gr_multiply_vii_sptr(object):
    """Proxy of C++ gr_multiply_vii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_vii_sptr
        __init__(self,  p) -> gr_multiply_vii_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_vii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_vii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_vii_sptr_detail(*args)

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

gr_multiply_vii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_vii(*args)
class gr_multiply_vss_sptr(object):
    """Proxy of C++ gr_multiply_vss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_multiply_vss_sptr
        __init__(self,  p) -> gr_multiply_vss_sptr
        """
        this = _gnuradio_swig_python.new_gr_multiply_vss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_multiply_vss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_multiply_vss_sptr_detail(*args)

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

gr_multiply_vss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.multiply_vss(*args)
class gr_mute_cc_sptr(object):
    """Proxy of C++ gr_mute_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_mute_cc_sptr
        __init__(self,  p) -> gr_mute_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_mute_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_mute_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_mute_cc_sptr
    __del__ = lambda self : None;
    def mute(*args):
        """mute(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_mute(*args)

    def set_mute(*args):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_set_mute(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_mute_cc_sptr_set_detail(*args)

gr_mute_cc_sptr_swigregister = _gnuradio_swig_python.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_python.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++ gr_mute_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_mute_ff_sptr
        __init__(self,  p) -> gr_mute_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_mute_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_mute_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_mute_ff_sptr
    __del__ = lambda self : None;
    def mute(*args):
        """mute(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_mute(*args)

    def set_mute(*args):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_set_mute(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_mute_ff_sptr_set_detail(*args)

gr_mute_ff_sptr_swigregister = _gnuradio_swig_python.gr_mute_ff_sptr_swigregister
gr_mute_ff_sptr_swigregister(gr_mute_ff_sptr)

def mute_cc(*args):
  """
    mute_cc(bool mute=False) -> gr_mute_cc_sptr
    mute_cc() -> gr_mute_cc_sptr
    """
  return _gnuradio_swig_python.mute_cc(*args)


def gr_mute_ff_block(*args):
  """gr_mute_ff_block(gr_mute_ff_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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++ gr_mute_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_mute_ii_sptr
        __init__(self,  p) -> gr_mute_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_mute_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_mute_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_mute_ii_sptr
    __del__ = lambda self : None;
    def mute(*args):
        """mute(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_mute(*args)

    def set_mute(*args):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_set_mute(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_mute_ii_sptr_set_detail(*args)

gr_mute_ii_sptr_swigregister = _gnuradio_swig_python.gr_mute_ii_sptr_swigregister
gr_mute_ii_sptr_swigregister(gr_mute_ii_sptr)

def mute_ff(*args):
  """
    mute_ff(bool mute=False) -> gr_mute_ff_sptr
    mute_ff() -> gr_mute_ff_sptr
    """
  return _gnuradio_swig_python.mute_ff(*args)


def gr_mute_ii_block(*args):
  """gr_mute_ii_block(gr_mute_ii_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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++ gr_mute_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_mute_ss_sptr
        __init__(self,  p) -> gr_mute_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_mute_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_mute_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_mute_ss_sptr
    __del__ = lambda self : None;
    def mute(*args):
        """mute(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_mute(*args)

    def set_mute(*args):
        """set_mute(self, bool mute)"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_set_mute(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_mute_ss_sptr_set_detail(*args)

gr_mute_ss_sptr_swigregister = _gnuradio_swig_python.gr_mute_ss_sptr_swigregister
gr_mute_ss_sptr_swigregister(gr_mute_ss_sptr)

def mute_ii(*args):
  """
    mute_ii(bool mute=False) -> gr_mute_ii_sptr
    mute_ii() -> gr_mute_ii_sptr
    """
  return _gnuradio_swig_python.mute_ii(*args)


def gr_mute_ss_block(*args):
  """gr_mute_ss_block(gr_mute_ss_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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++ gr_noise_source_c_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 __init__(self, *args): 
        """
        __init__(self) -> gr_noise_source_c_sptr
        __init__(self,  p) -> gr_noise_source_c_sptr
        """
        this = _gnuradio_swig_python.new_gr_noise_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_noise_source_c_sptr
    __del__ = lambda self : None;
    def set_type(*args):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_set_type(*args)

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_noise_source_c_sptr_set_detail(*args)

gr_noise_source_c_sptr_swigregister = _gnuradio_swig_python.gr_noise_source_c_sptr_swigregister
gr_noise_source_c_sptr_swigregister(gr_noise_source_c_sptr)

def mute_ss(*args):
  """
    mute_ss(bool mute=False) -> gr_mute_ss_sptr
    mute_ss() -> gr_mute_ss_sptr
    """
  return _gnuradio_swig_python.mute_ss(*args)


def gr_noise_source_c_block(*args):
  """gr_noise_source_c_block(gr_noise_source_c_sptr r) -> gr_block_sptr"""
  return _gnuradio_swig_python.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++ gr_noise_source_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_noise_source_f_sptr
        __init__(self,  p) -> gr_noise_source_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_noise_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_noise_source_f_sptr
    __del__ = lambda self : None;
    def set_type(*args):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_set_type(*args)

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_noise_source_f_sptr_set_detail(*args)

gr_noise_source_f_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_noise_source_i_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 __init__(self, *args): 
        """
        __init__(self) -> gr_noise_source_i_sptr
        __init__(self,  p) -> gr_noise_source_i_sptr
        """
        this = _gnuradio_swig_python.new_gr_noise_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_noise_source_i_sptr
    __del__ = lambda self : None;
    def set_type(*args):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_set_type(*args)

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_noise_source_i_sptr_set_detail(*args)

gr_noise_source_i_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_noise_source_s_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 __init__(self, *args): 
        """
        __init__(self) -> gr_noise_source_s_sptr
        __init__(self,  p) -> gr_noise_source_s_sptr
        """
        this = _gnuradio_swig_python.new_gr_noise_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_noise_source_s_sptr
    __del__ = lambda self : None;
    def set_type(*args):
        """set_type(self, gr_noise_type_t type)"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_set_type(*args)

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_noise_source_s_sptr_set_detail(*args)

gr_noise_source_s_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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_packed_to_unpacked_bb_sptr(object):
    """Proxy of C++ gr_packed_to_unpacked_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_packed_to_unpacked_bb_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_packed_to_unpacked_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_packed_to_unpacked_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_set_detail(*args)

gr_packed_to_unpacked_bb_sptr_swigregister = _gnuradio_swig_python.gr_packed_to_unpacked_bb_sptr_swigregister
gr_packed_to_unpacked_bb_sptr_swigregister(gr_packed_to_unpacked_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_python.noise_source_s(*args)


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_python.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_python.packed_to_unpacked_bb(*args)
class gr_packed_to_unpacked_ii_sptr(object):
    """Proxy of C++ gr_packed_to_unpacked_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_packed_to_unpacked_ii_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_packed_to_unpacked_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_packed_to_unpacked_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ii_sptr_set_detail(*args)

gr_packed_to_unpacked_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.packed_to_unpacked_ii(*args)
class gr_packed_to_unpacked_ss_sptr(object):
    """Proxy of C++ gr_packed_to_unpacked_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_packed_to_unpacked_ss_sptr
        __init__(self,  p) -> gr_packed_to_unpacked_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_packed_to_unpacked_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_packed_to_unpacked_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_packed_to_unpacked_ss_sptr_set_detail(*args)

gr_packed_to_unpacked_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.packed_to_unpacked_ss(*args)
class gr_sig_source_c_sptr(object):
    """Proxy of C++ gr_sig_source_c_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sig_source_c_sptr
        __init__(self,  p) -> gr_sig_source_c_sptr
        """
        this = _gnuradio_swig_python.new_gr_sig_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sig_source_c_sptr
    __del__ = lambda self : None;
    def sampling_freq(*args):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_sampling_freq(*args)

    def waveform(*args):
        """waveform(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_waveform(*args)

    def frequency(*args):
        """frequency(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_frequency(*args)

    def amplitude(*args):
        """amplitude(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_amplitude(*args)

    def offset(*args):
        """offset(self) -> gr_complex"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_offset(*args)

    def set_sampling_freq(*args):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_set_sampling_freq(*args)

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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sig_source_c_sptr_set_detail(*args)

gr_sig_source_c_sptr_swigregister = _gnuradio_swig_python.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_python.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++ gr_sig_source_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sig_source_f_sptr
        __init__(self,  p) -> gr_sig_source_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_sig_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sig_source_f_sptr
    __del__ = lambda self : None;
    def sampling_freq(*args):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_sampling_freq(*args)

    def waveform(*args):
        """waveform(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_waveform(*args)

    def frequency(*args):
        """frequency(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_frequency(*args)

    def amplitude(*args):
        """amplitude(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_amplitude(*args)

    def offset(*args):
        """offset(self) -> float"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_offset(*args)

    def set_sampling_freq(*args):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_set_sampling_freq(*args)

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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sig_source_f_sptr_set_detail(*args)

gr_sig_source_f_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_sig_source_i_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sig_source_i_sptr
        __init__(self,  p) -> gr_sig_source_i_sptr
        """
        this = _gnuradio_swig_python.new_gr_sig_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sig_source_i_sptr
    __del__ = lambda self : None;
    def sampling_freq(*args):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_sampling_freq(*args)

    def waveform(*args):
        """waveform(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_waveform(*args)

    def frequency(*args):
        """frequency(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_frequency(*args)

    def amplitude(*args):
        """amplitude(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_amplitude(*args)

    def offset(*args):
        """offset(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_offset(*args)

    def set_sampling_freq(*args):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_set_sampling_freq(*args)

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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sig_source_i_sptr_set_detail(*args)

gr_sig_source_i_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_sig_source_s_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sig_source_s_sptr
        __init__(self,  p) -> gr_sig_source_s_sptr
        """
        this = _gnuradio_swig_python.new_gr_sig_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sig_source_s_sptr
    __del__ = lambda self : None;
    def sampling_freq(*args):
        """sampling_freq(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_sampling_freq(*args)

    def waveform(*args):
        """waveform(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_waveform(*args)

    def frequency(*args):
        """frequency(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_frequency(*args)

    def amplitude(*args):
        """amplitude(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_amplitude(*args)

    def offset(*args):
        """offset(self) -> short"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_offset(*args)

    def set_sampling_freq(*args):
        """set_sampling_freq(self, double sampling_freq)"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_set_sampling_freq(*args)

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

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

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

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

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sig_source_s_sptr_set_detail(*args)

gr_sig_source_s_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_sub_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sub_cc_sptr
        __init__(self,  p) -> gr_sub_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_sub_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sub_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sub_cc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sub_cc_sptr_set_detail(*args)

gr_sub_cc_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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(*args):
  """sub_cc() -> gr_sub_cc_sptr"""
  return _gnuradio_swig_python.sub_cc(*args)
class gr_sub_ff_sptr(object):
    """Proxy of C++ gr_sub_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sub_ff_sptr
        __init__(self,  p) -> gr_sub_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_sub_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sub_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sub_ff_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sub_ff_sptr_set_detail(*args)

gr_sub_ff_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """sub_ff() -> gr_sub_ff_sptr"""
  return _gnuradio_swig_python.sub_ff(*args)
class gr_sub_ii_sptr(object):
    """Proxy of C++ gr_sub_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sub_ii_sptr
        __init__(self,  p) -> gr_sub_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_sub_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sub_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sub_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sub_ii_sptr_set_detail(*args)

gr_sub_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """sub_ii() -> gr_sub_ii_sptr"""
  return _gnuradio_swig_python.sub_ii(*args)
class gr_sub_ss_sptr(object):
    """Proxy of C++ gr_sub_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_sub_ss_sptr
        __init__(self,  p) -> gr_sub_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_sub_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_sub_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_sub_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_sub_ss_sptr_set_detail(*args)

gr_sub_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """sub_ss() -> gr_sub_ss_sptr"""
  return _gnuradio_swig_python.sub_ss(*args)
class gr_unpacked_to_packed_bb_sptr(object):
    """Proxy of C++ gr_unpacked_to_packed_bb_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 __init__(self, *args): 
        """
        __init__(self) -> gr_unpacked_to_packed_bb_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_bb_sptr
        """
        this = _gnuradio_swig_python.new_gr_unpacked_to_packed_bb_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_unpacked_to_packed_bb_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_bb_sptr_set_detail(*args)

gr_unpacked_to_packed_bb_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.unpacked_to_packed_bb(*args)
class gr_unpacked_to_packed_ii_sptr(object):
    """Proxy of C++ gr_unpacked_to_packed_ii_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 __init__(self, *args): 
        """
        __init__(self) -> gr_unpacked_to_packed_ii_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_ii_sptr
        """
        this = _gnuradio_swig_python.new_gr_unpacked_to_packed_ii_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_unpacked_to_packed_ii_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ii_sptr_set_detail(*args)

gr_unpacked_to_packed_ii_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.unpacked_to_packed_ii(*args)
class gr_unpacked_to_packed_ss_sptr(object):
    """Proxy of C++ gr_unpacked_to_packed_ss_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 __init__(self, *args): 
        """
        __init__(self) -> gr_unpacked_to_packed_ss_sptr
        __init__(self,  p) -> gr_unpacked_to_packed_ss_sptr
        """
        this = _gnuradio_swig_python.new_gr_unpacked_to_packed_ss_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_unpacked_to_packed_ss_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_unpacked_to_packed_ss_sptr_set_detail(*args)

gr_unpacked_to_packed_ss_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.unpacked_to_packed_ss(*args)
class gr_vector_sink_b_sptr(object):
    """Proxy of C++ gr_vector_sink_b_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_sink_b_sptr
        __init__(self,  p) -> gr_vector_sink_b_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_sink_b_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_sink_b_sptr
    __del__ = lambda self : None;
    def data(*args):
        """data(self) -> __dummy_0__"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_data(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_sink_b_sptr_set_detail(*args)

gr_vector_sink_b_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """vector_sink_b() -> gr_vector_sink_b_sptr"""
  return _gnuradio_swig_python.vector_sink_b(*args)
class gr_vector_sink_c_sptr(object):
    """Proxy of C++ gr_vector_sink_c_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_sink_c_sptr
        __init__(self,  p) -> gr_vector_sink_c_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_sink_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_sink_c_sptr
    __del__ = lambda self : None;
    def data(*args):
        """data(self) -> std::vector<(gr_complex,std::allocator<(gr_complex)>)>"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_data(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_sink_c_sptr_set_detail(*args)

gr_vector_sink_c_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """vector_sink_c() -> gr_vector_sink_c_sptr"""
  return _gnuradio_swig_python.vector_sink_c(*args)
class gr_vector_sink_f_sptr(object):
    """Proxy of C++ gr_vector_sink_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_sink_f_sptr
        __init__(self,  p) -> gr_vector_sink_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_sink_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_sink_f_sptr
    __del__ = lambda self : None;
    def data(*args):
        """data(self) -> __dummy_4__"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_data(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_sink_f_sptr_set_detail(*args)

gr_vector_sink_f_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """vector_sink_f() -> gr_vector_sink_f_sptr"""
  return _gnuradio_swig_python.vector_sink_f(*args)
class gr_vector_sink_i_sptr(object):
    """Proxy of C++ gr_vector_sink_i_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_sink_i_sptr
        __init__(self,  p) -> gr_vector_sink_i_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_sink_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_sink_i_sptr
    __del__ = lambda self : None;
    def data(*args):
        """data(self) -> __dummy_3__"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_data(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_sink_i_sptr_set_detail(*args)

gr_vector_sink_i_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """vector_sink_i() -> gr_vector_sink_i_sptr"""
  return _gnuradio_swig_python.vector_sink_i(*args)
class gr_vector_sink_s_sptr(object):
    """Proxy of C++ gr_vector_sink_s_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_sink_s_sptr
        __init__(self,  p) -> gr_vector_sink_s_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_sink_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_sink_s_sptr
    __del__ = lambda self : None;
    def data(*args):
        """data(self) -> __dummy_2__"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_data(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_sink_s_sptr_set_detail(*args)

gr_vector_sink_s_sptr_swigregister = _gnuradio_swig_python.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_python.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(*args):
  """vector_sink_s() -> gr_vector_sink_s_sptr"""
  return _gnuradio_swig_python.vector_sink_s(*args)
class gr_vector_source_b_sptr(object):
    """Proxy of C++ gr_vector_source_b_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_source_b_sptr
        __init__(self,  p) -> gr_vector_source_b_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_source_b_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_source_b_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_source_b_sptr_set_detail(*args)

gr_vector_source_b_sptr_swigregister = _gnuradio_swig_python.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_python.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++ gr_vector_source_c_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_source_c_sptr
        __init__(self,  p) -> gr_vector_source_c_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_source_c_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_source_c_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_source_c_sptr_set_detail(*args)

gr_vector_source_c_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_vector_source_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_source_f_sptr
        __init__(self,  p) -> gr_vector_source_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_source_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_source_f_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_source_f_sptr_set_detail(*args)

gr_vector_source_f_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_vector_source_i_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_source_i_sptr
        __init__(self,  p) -> gr_vector_source_i_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_source_i_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_source_i_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_source_i_sptr_set_detail(*args)

gr_vector_source_i_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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++ gr_vector_source_s_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 __init__(self, *args): 
        """
        __init__(self) -> gr_vector_source_s_sptr
        __init__(self,  p) -> gr_vector_source_s_sptr
        """
        this = _gnuradio_swig_python.new_gr_vector_source_s_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_vector_source_s_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_vector_source_s_sptr_set_detail(*args)

gr_vector_source_s_sptr_swigregister = _gnuradio_swig_python.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_python.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_python.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_iir_filter_ffd_sptr(object):
    """Proxy of C++ gr_iir_filter_ffd_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 __init__(self, *args): 
        """
        __init__(self) -> gr_iir_filter_ffd_sptr
        __init__(self,  p) -> gr_iir_filter_ffd_sptr
        """
        this = _gnuradio_swig_python.new_gr_iir_filter_ffd_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_iir_filter_ffd_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_5__ fftaps, __dummy_5__ fbtaps)"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_iir_filter_ffd_sptr_set_detail(*args)

gr_iir_filter_ffd_sptr_swigregister = _gnuradio_swig_python.gr_iir_filter_ffd_sptr_swigregister
gr_iir_filter_ffd_sptr_swigregister(gr_iir_filter_ffd_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_python.vector_source_s(*args)


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


def iir_filter_ffd(*args):
  """iir_filter_ffd(__dummy_5__ fftaps, __dummy_5__ fbtaps) -> gr_iir_filter_ffd_sptr"""
  return _gnuradio_swig_python.iir_filter_ffd(*args)
class gr_single_pole_iir_filter_ff_sptr(object):
    """Proxy of C++ gr_single_pole_iir_filter_ff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_single_pole_iir_filter_ff_sptr
        __init__(self,  p) -> gr_single_pole_iir_filter_ff_sptr
        """
        this = _gnuradio_swig_python.new_gr_single_pole_iir_filter_ff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_single_pole_iir_filter_ff_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, double alpha)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_set_detail(*args)

gr_single_pole_iir_filter_ff_sptr_swigregister = _gnuradio_swig_python.gr_single_pole_iir_filter_ff_sptr_swigregister
gr_single_pole_iir_filter_ff_sptr_swigregister(gr_single_pole_iir_filter_ff_sptr)


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

class gr_single_pole_iir_filter_cc_sptr(object):
    """Proxy of C++ gr_single_pole_iir_filter_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_single_pole_iir_filter_cc_sptr
        __init__(self,  p) -> gr_single_pole_iir_filter_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_single_pole_iir_filter_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_single_pole_iir_filter_cc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, double alpha)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_set_detail(*args)

gr_single_pole_iir_filter_cc_sptr_swigregister = _gnuradio_swig_python.gr_single_pole_iir_filter_cc_sptr_swigregister
gr_single_pole_iir_filter_cc_sptr_swigregister(gr_single_pole_iir_filter_cc_sptr)

def single_pole_iir_filter_ff(*args):
  """
    single_pole_iir_filter_ff(double alpha, unsigned int vlen=1) -> gr_single_pole_iir_filter_ff_sptr
    single_pole_iir_filter_ff(double alpha) -> gr_single_pole_iir_filter_ff_sptr
    """
  return _gnuradio_swig_python.single_pole_iir_filter_ff(*args)


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

class gr_hilbert_fc_sptr(object):
    """Proxy of C++ gr_hilbert_fc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_hilbert_fc_sptr
        __init__(self,  p) -> gr_hilbert_fc_sptr
        """
        this = _gnuradio_swig_python.new_gr_hilbert_fc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_hilbert_fc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_hilbert_fc_sptr_set_detail(*args)

gr_hilbert_fc_sptr_swigregister = _gnuradio_swig_python.gr_hilbert_fc_sptr_swigregister
gr_hilbert_fc_sptr_swigregister(gr_hilbert_fc_sptr)

def single_pole_iir_filter_cc(*args):
  """
    single_pole_iir_filter_cc(double alpha, unsigned int vlen=1) -> gr_single_pole_iir_filter_cc_sptr
    single_pole_iir_filter_cc(double alpha) -> gr_single_pole_iir_filter_cc_sptr
    """
  return _gnuradio_swig_python.single_pole_iir_filter_cc(*args)


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


def hilbert_fc(*args):
  """hilbert_fc(unsigned int ntaps) -> gr_hilbert_fc_sptr"""
  return _gnuradio_swig_python.hilbert_fc(*args)
class gr_filter_delay_fc_sptr(object):
    """Proxy of C++ gr_filter_delay_fc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_filter_delay_fc_sptr
        __init__(self,  p) -> gr_filter_delay_fc_sptr
        """
        this = _gnuradio_swig_python.new_gr_filter_delay_fc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_filter_delay_fc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_filter_delay_fc_sptr_set_detail(*args)

gr_filter_delay_fc_sptr_swigregister = _gnuradio_swig_python.gr_filter_delay_fc_sptr_swigregister
gr_filter_delay_fc_sptr_swigregister(gr_filter_delay_fc_sptr)


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


def filter_delay_fc(*args):
  """filter_delay_fc(__dummy_4__ taps) -> gr_filter_delay_fc_sptr"""
  return _gnuradio_swig_python.filter_delay_fc(*args)
class gr_fft_filter_ccc_sptr(object):
    """Proxy of C++ gr_fft_filter_ccc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fft_filter_ccc_sptr
        __init__(self,  p) -> gr_fft_filter_ccc_sptr
        """
        this = _gnuradio_swig_python.new_gr_fft_filter_ccc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fft_filter_ccc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fft_filter_ccc_sptr_set_detail(*args)

gr_fft_filter_ccc_sptr_swigregister = _gnuradio_swig_python.gr_fft_filter_ccc_sptr_swigregister
gr_fft_filter_ccc_sptr_swigregister(gr_fft_filter_ccc_sptr)


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


def fft_filter_ccc(*args):
  """fft_filter_ccc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_fft_filter_ccc_sptr"""
  return _gnuradio_swig_python.fft_filter_ccc(*args)
class gr_fft_filter_fff_sptr(object):
    """Proxy of C++ gr_fft_filter_fff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fft_filter_fff_sptr
        __init__(self,  p) -> gr_fft_filter_fff_sptr
        """
        this = _gnuradio_swig_python.new_gr_fft_filter_fff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fft_filter_fff_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fft_filter_fff_sptr_set_detail(*args)

gr_fft_filter_fff_sptr_swigregister = _gnuradio_swig_python.gr_fft_filter_fff_sptr_swigregister
gr_fft_filter_fff_sptr_swigregister(gr_fft_filter_fff_sptr)


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


def fft_filter_fff(*args):
  """fft_filter_fff(int decimation, __dummy_4__ taps) -> gr_fft_filter_fff_sptr"""
  return _gnuradio_swig_python.fft_filter_fff(*args)
class gr_goertzel_fc_sptr(object):
    """Proxy of C++ gr_goertzel_fc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_goertzel_fc_sptr
        __init__(self,  p) -> gr_goertzel_fc_sptr
        """
        this = _gnuradio_swig_python.new_gr_goertzel_fc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_goertzel_fc_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_goertzel_fc_sptr_set_detail(*args)

gr_goertzel_fc_sptr_swigregister = _gnuradio_swig_python.gr_goertzel_fc_sptr_swigregister
gr_goertzel_fc_sptr_swigregister(gr_goertzel_fc_sptr)


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


def goertzel_fc(*args):
  """goertzel_fc(int rate, int len, float freq) -> gr_goertzel_fc_sptr"""
  return _gnuradio_swig_python.goertzel_fc(*args)
class gr_cma_equalizer_cc_sptr(object):
    """Proxy of C++ gr_cma_equalizer_cc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_cma_equalizer_cc_sptr
        __init__(self,  p) -> gr_cma_equalizer_cc_sptr
        """
        this = _gnuradio_swig_python.new_gr_cma_equalizer_cc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_cma_equalizer_cc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_set_detail(*args)

gr_cma_equalizer_cc_sptr_swigregister = _gnuradio_swig_python.gr_cma_equalizer_cc_sptr_swigregister
gr_cma_equalizer_cc_sptr_swigregister(gr_cma_equalizer_cc_sptr)


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

class gr_adaptive_fir_ccf(gr_sync_decimator):
    """Proxy of C++ gr_adaptive_fir_ccf class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_adaptive_fir_ccf_set_taps(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_adaptive_fir_ccf
    __del__ = lambda self : None;
gr_adaptive_fir_ccf_swigregister = _gnuradio_swig_python.gr_adaptive_fir_ccf_swigregister
gr_adaptive_fir_ccf_swigregister(gr_adaptive_fir_ccf)


def cma_equalizer_cc(*args):
  """cma_equalizer_cc(int num_taps, float modulus, float mu) -> gr_cma_equalizer_cc_sptr"""
  return _gnuradio_swig_python.cma_equalizer_cc(*args)
class gr_fir_filter_ccc_sptr(object):
    """Proxy of C++ gr_fir_filter_ccc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_ccc_sptr
        __init__(self,  p) -> gr_fir_filter_ccc_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_ccc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_ccc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_ccc_sptr_set_detail(*args)

gr_fir_filter_ccc_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_ccc_sptr_swigregister
gr_fir_filter_ccc_sptr_swigregister(gr_fir_filter_ccc_sptr)


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


def fir_filter_ccc(*args):
  """fir_filter_ccc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_fir_filter_ccc_sptr"""
  return _gnuradio_swig_python.fir_filter_ccc(*args)
class gr_fir_filter_ccf_sptr(object):
    """Proxy of C++ gr_fir_filter_ccf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_ccf_sptr
        __init__(self,  p) -> gr_fir_filter_ccf_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_ccf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_ccf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_ccf_sptr_set_detail(*args)

gr_fir_filter_ccf_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_ccf_sptr_swigregister
gr_fir_filter_ccf_sptr_swigregister(gr_fir_filter_ccf_sptr)


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


def fir_filter_ccf(*args):
  """fir_filter_ccf(int decimation, __dummy_4__ taps) -> gr_fir_filter_ccf_sptr"""
  return _gnuradio_swig_python.fir_filter_ccf(*args)
class gr_fir_filter_fcc_sptr(object):
    """Proxy of C++ gr_fir_filter_fcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_fcc_sptr
        __init__(self,  p) -> gr_fir_filter_fcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_fcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_fcc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_fcc_sptr_set_detail(*args)

gr_fir_filter_fcc_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_fcc_sptr_swigregister
gr_fir_filter_fcc_sptr_swigregister(gr_fir_filter_fcc_sptr)


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


def fir_filter_fcc(*args):
  """fir_filter_fcc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_fir_filter_fcc_sptr"""
  return _gnuradio_swig_python.fir_filter_fcc(*args)
class gr_fir_filter_fff_sptr(object):
    """Proxy of C++ gr_fir_filter_fff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_fff_sptr
        __init__(self,  p) -> gr_fir_filter_fff_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_fff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_fff_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_fff_sptr_set_detail(*args)

gr_fir_filter_fff_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_fff_sptr_swigregister
gr_fir_filter_fff_sptr_swigregister(gr_fir_filter_fff_sptr)


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


def fir_filter_fff(*args):
  """fir_filter_fff(int decimation, __dummy_4__ taps) -> gr_fir_filter_fff_sptr"""
  return _gnuradio_swig_python.fir_filter_fff(*args)
class gr_fir_filter_fsf_sptr(object):
    """Proxy of C++ gr_fir_filter_fsf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_fsf_sptr
        __init__(self,  p) -> gr_fir_filter_fsf_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_fsf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_fsf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_fsf_sptr_set_detail(*args)

gr_fir_filter_fsf_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_fsf_sptr_swigregister
gr_fir_filter_fsf_sptr_swigregister(gr_fir_filter_fsf_sptr)


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


def fir_filter_fsf(*args):
  """fir_filter_fsf(int decimation, __dummy_4__ taps) -> gr_fir_filter_fsf_sptr"""
  return _gnuradio_swig_python.fir_filter_fsf(*args)
class gr_fir_filter_scc_sptr(object):
    """Proxy of C++ gr_fir_filter_scc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_fir_filter_scc_sptr
        __init__(self,  p) -> gr_fir_filter_scc_sptr
        """
        this = _gnuradio_swig_python.new_gr_fir_filter_scc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_fir_filter_scc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_fir_filter_scc_sptr_set_detail(*args)

gr_fir_filter_scc_sptr_swigregister = _gnuradio_swig_python.gr_fir_filter_scc_sptr_swigregister
gr_fir_filter_scc_sptr_swigregister(gr_fir_filter_scc_sptr)


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


def fir_filter_scc(*args):
  """fir_filter_scc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_fir_filter_scc_sptr"""
  return _gnuradio_swig_python.fir_filter_scc(*args)
class gr_freq_xlating_fir_filter_ccc_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_ccc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_ccc_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_ccc_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_ccc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_ccc_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_ccc_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccc_sptr_swigregister
gr_freq_xlating_fir_filter_ccc_sptr_swigregister(gr_freq_xlating_fir_filter_ccc_sptr)


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


def freq_xlating_fir_filter_ccc(*args):
  """
    freq_xlating_fir_filter_ccc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps, 
        double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_ccc_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_ccc(*args)
class gr_freq_xlating_fir_filter_ccf_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_ccf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_ccf_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_ccf_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_ccf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_ccf_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_ccf_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_ccf_sptr_swigregister
gr_freq_xlating_fir_filter_ccf_sptr_swigregister(gr_freq_xlating_fir_filter_ccf_sptr)


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


def freq_xlating_fir_filter_ccf(*args):
  """
    freq_xlating_fir_filter_ccf(int decimation, __dummy_4__ taps, double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_ccf_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_ccf(*args)
class gr_freq_xlating_fir_filter_fcc_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_fcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_fcc_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_fcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_fcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_fcc_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_fcc_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcc_sptr_swigregister
gr_freq_xlating_fir_filter_fcc_sptr_swigregister(gr_freq_xlating_fir_filter_fcc_sptr)


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


def freq_xlating_fir_filter_fcc(*args):
  """
    freq_xlating_fir_filter_fcc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps, 
        double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_fcc_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_fcc(*args)
class gr_freq_xlating_fir_filter_fcf_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_fcf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_fcf_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_fcf_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_fcf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_fcf_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_fcf_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_fcf_sptr_swigregister
gr_freq_xlating_fir_filter_fcf_sptr_swigregister(gr_freq_xlating_fir_filter_fcf_sptr)


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


def freq_xlating_fir_filter_fcf(*args):
  """
    freq_xlating_fir_filter_fcf(int decimation, __dummy_4__ taps, double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_fcf_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_fcf(*args)
class gr_freq_xlating_fir_filter_scc_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_scc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_scc_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_scc_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_scc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_scc_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_scc_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_scc_sptr_swigregister
gr_freq_xlating_fir_filter_scc_sptr_swigregister(gr_freq_xlating_fir_filter_scc_sptr)


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


def freq_xlating_fir_filter_scc(*args):
  """
    freq_xlating_fir_filter_scc(int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps, 
        double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_scc_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_scc(*args)
class gr_freq_xlating_fir_filter_scf_sptr(object):
    """Proxy of C++ gr_freq_xlating_fir_filter_scf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_freq_xlating_fir_filter_scf_sptr
        __init__(self,  p) -> gr_freq_xlating_fir_filter_scf_sptr
        """
        this = _gnuradio_swig_python.new_gr_freq_xlating_fir_filter_scf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_freq_xlating_fir_filter_scf_sptr
    __del__ = lambda self : None;
    def set_center_freq(*args):
        """set_center_freq(self, double center_freq)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_set_center_freq(*args)

    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_set_detail(*args)

gr_freq_xlating_fir_filter_scf_sptr_swigregister = _gnuradio_swig_python.gr_freq_xlating_fir_filter_scf_sptr_swigregister
gr_freq_xlating_fir_filter_scf_sptr_swigregister(gr_freq_xlating_fir_filter_scf_sptr)


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


def freq_xlating_fir_filter_scf(*args):
  """
    freq_xlating_fir_filter_scf(int decimation, __dummy_4__ taps, double center_freq, 
        double sampling_freq) -> gr_freq_xlating_fir_filter_scf_sptr
    """
  return _gnuradio_swig_python.freq_xlating_fir_filter_scf(*args)
class gr_interp_fir_filter_ccc_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_ccc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_ccc_sptr
        __init__(self,  p) -> gr_interp_fir_filter_ccc_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_ccc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_ccc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_set_detail(*args)

gr_interp_fir_filter_ccc_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_ccc_sptr_swigregister
gr_interp_fir_filter_ccc_sptr_swigregister(gr_interp_fir_filter_ccc_sptr)


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


def interp_fir_filter_ccc(*args):
  """interp_fir_filter_ccc(int interpolation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_interp_fir_filter_ccc_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_ccc(*args)
class gr_interp_fir_filter_ccf_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_ccf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_ccf_sptr
        __init__(self,  p) -> gr_interp_fir_filter_ccf_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_ccf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_ccf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_set_detail(*args)

gr_interp_fir_filter_ccf_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_ccf_sptr_swigregister
gr_interp_fir_filter_ccf_sptr_swigregister(gr_interp_fir_filter_ccf_sptr)


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


def interp_fir_filter_ccf(*args):
  """interp_fir_filter_ccf(int interpolation, __dummy_4__ taps) -> gr_interp_fir_filter_ccf_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_ccf(*args)
class gr_interp_fir_filter_fcc_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_fcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_fcc_sptr
        __init__(self,  p) -> gr_interp_fir_filter_fcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_fcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_fcc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_set_detail(*args)

gr_interp_fir_filter_fcc_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_fcc_sptr_swigregister
gr_interp_fir_filter_fcc_sptr_swigregister(gr_interp_fir_filter_fcc_sptr)


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


def interp_fir_filter_fcc(*args):
  """interp_fir_filter_fcc(int interpolation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_interp_fir_filter_fcc_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_fcc(*args)
class gr_interp_fir_filter_fff_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_fff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_fff_sptr
        __init__(self,  p) -> gr_interp_fir_filter_fff_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_fff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_fff_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_set_detail(*args)

gr_interp_fir_filter_fff_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_fff_sptr_swigregister
gr_interp_fir_filter_fff_sptr_swigregister(gr_interp_fir_filter_fff_sptr)


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


def interp_fir_filter_fff(*args):
  """interp_fir_filter_fff(int interpolation, __dummy_4__ taps) -> gr_interp_fir_filter_fff_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_fff(*args)
class gr_interp_fir_filter_fsf_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_fsf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_fsf_sptr
        __init__(self,  p) -> gr_interp_fir_filter_fsf_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_fsf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_fsf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_set_detail(*args)

gr_interp_fir_filter_fsf_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_fsf_sptr_swigregister
gr_interp_fir_filter_fsf_sptr_swigregister(gr_interp_fir_filter_fsf_sptr)


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


def interp_fir_filter_fsf(*args):
  """interp_fir_filter_fsf(int interpolation, __dummy_4__ taps) -> gr_interp_fir_filter_fsf_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_fsf(*args)
class gr_interp_fir_filter_scc_sptr(object):
    """Proxy of C++ gr_interp_fir_filter_scc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_interp_fir_filter_scc_sptr
        __init__(self,  p) -> gr_interp_fir_filter_scc_sptr
        """
        this = _gnuradio_swig_python.new_gr_interp_fir_filter_scc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_interp_fir_filter_scc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_set_detail(*args)

gr_interp_fir_filter_scc_sptr_swigregister = _gnuradio_swig_python.gr_interp_fir_filter_scc_sptr_swigregister
gr_interp_fir_filter_scc_sptr_swigregister(gr_interp_fir_filter_scc_sptr)


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


def interp_fir_filter_scc(*args):
  """interp_fir_filter_scc(int interpolation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_interp_fir_filter_scc_sptr"""
  return _gnuradio_swig_python.interp_fir_filter_scc(*args)
class gr_rational_resampler_base_ccc_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_ccc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_ccc_sptr
        __init__(self,  p) -> gr_rational_resampler_base_ccc_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_ccc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_ccc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_set_detail(*args)

gr_rational_resampler_base_ccc_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_ccc_sptr_swigregister
gr_rational_resampler_base_ccc_sptr_swigregister(gr_rational_resampler_base_ccc_sptr)


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


def rational_resampler_base_ccc(*args):
  """rational_resampler_base_ccc(int interpolation, int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_rational_resampler_base_ccc_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_ccc(*args)
class gr_rational_resampler_base_ccf_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_ccf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_ccf_sptr
        __init__(self,  p) -> gr_rational_resampler_base_ccf_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_ccf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_ccf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_set_detail(*args)

gr_rational_resampler_base_ccf_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_ccf_sptr_swigregister
gr_rational_resampler_base_ccf_sptr_swigregister(gr_rational_resampler_base_ccf_sptr)


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


def rational_resampler_base_ccf(*args):
  """rational_resampler_base_ccf(int interpolation, int decimation, __dummy_4__ taps) -> gr_rational_resampler_base_ccf_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_ccf(*args)
class gr_rational_resampler_base_fcc_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_fcc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_fcc_sptr
        __init__(self,  p) -> gr_rational_resampler_base_fcc_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_fcc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_fcc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_set_detail(*args)

gr_rational_resampler_base_fcc_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_fcc_sptr_swigregister
gr_rational_resampler_base_fcc_sptr_swigregister(gr_rational_resampler_base_fcc_sptr)


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


def rational_resampler_base_fcc(*args):
  """rational_resampler_base_fcc(int interpolation, int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_rational_resampler_base_fcc_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_fcc(*args)
class gr_rational_resampler_base_fff_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_fff_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_fff_sptr
        __init__(self,  p) -> gr_rational_resampler_base_fff_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_fff_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_fff_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_set_detail(*args)

gr_rational_resampler_base_fff_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_fff_sptr_swigregister
gr_rational_resampler_base_fff_sptr_swigregister(gr_rational_resampler_base_fff_sptr)


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


def rational_resampler_base_fff(*args):
  """rational_resampler_base_fff(int interpolation, int decimation, __dummy_4__ taps) -> gr_rational_resampler_base_fff_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_fff(*args)
class gr_rational_resampler_base_fsf_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_fsf_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_fsf_sptr
        __init__(self,  p) -> gr_rational_resampler_base_fsf_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_fsf_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_fsf_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, __dummy_4__ taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_set_detail(*args)

gr_rational_resampler_base_fsf_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_fsf_sptr_swigregister
gr_rational_resampler_base_fsf_sptr_swigregister(gr_rational_resampler_base_fsf_sptr)


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


def rational_resampler_base_fsf(*args):
  """rational_resampler_base_fsf(int interpolation, int decimation, __dummy_4__ taps) -> gr_rational_resampler_base_fsf_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_fsf(*args)
class gr_rational_resampler_base_scc_sptr(object):
    """Proxy of C++ gr_rational_resampler_base_scc_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 __init__(self, *args): 
        """
        __init__(self) -> gr_rational_resampler_base_scc_sptr
        __init__(self,  p) -> gr_rational_resampler_base_scc_sptr
        """
        this = _gnuradio_swig_python.new_gr_rational_resampler_base_scc_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_rational_resampler_base_scc_sptr
    __del__ = lambda self : None;
    def set_taps(*args):
        """set_taps(self, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_set_taps(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_set_detail(*args)

gr_rational_resampler_base_scc_sptr_swigregister = _gnuradio_swig_python.gr_rational_resampler_base_scc_sptr_swigregister
gr_rational_resampler_base_scc_sptr_swigregister(gr_rational_resampler_base_scc_sptr)


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


def rational_resampler_base_scc(*args):
  """rational_resampler_base_scc(int interpolation, int decimation, std::vector<(gr_complex,std::allocator<(gr_complex)>)> taps) -> gr_rational_resampler_base_scc_sptr"""
  return _gnuradio_swig_python.rational_resampler_base_scc(*args)
class gr_file_sink_sptr(object):
    """Proxy of C++ gr_file_sink_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 __init__(self, *args): 
        """
        __init__(self) -> gr_file_sink_sptr
        __init__(self,  p) -> gr_file_sink_sptr
        """
        this = _gnuradio_swig_python.new_gr_file_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_file_sink_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_file_sink_sptr
    __del__ = lambda self : None;
    def open(*args):
        """open(self, char filename) -> bool"""
        return _gnuradio_swig_python.gr_file_sink_sptr_open(*args)

    def close(*args):
        """close(self)"""
        return _gnuradio_swig_python.gr_file_sink_sptr_close(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_file_sink_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_sink_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_sink_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_file_sink_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_file_sink_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_file_sink_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_file_sink_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_file_sink_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_file_sink_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_file_sink_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_file_sink_sptr_set_detail(*args)

gr_file_sink_sptr_swigregister = _gnuradio_swig_python.gr_file_sink_sptr_swigregister
gr_file_sink_sptr_swigregister(gr_file_sink_sptr)


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


def file_sink(*args):
  """file_sink(size_t itemsize, char filename) -> gr_file_sink_sptr"""
  return _gnuradio_swig_python.file_sink(*args)
SEEK_SET = _gnuradio_swig_python.SEEK_SET
SEEK_CUR = _gnuradio_swig_python.SEEK_CUR
SEEK_END = _gnuradio_swig_python.SEEK_END
class gr_file_source_sptr(object):
    """Proxy of C++ gr_file_source_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 __init__(self, *args): 
        """
        __init__(self) -> gr_file_source_sptr
        __init__(self,  p) -> gr_file_source_sptr
        """
        this = _gnuradio_swig_python.new_gr_file_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_file_source_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_file_source_sptr
    __del__ = lambda self : None;
    def seek(*args):
        """seek(self, long seek_point, int whence) -> bool"""
        return _gnuradio_swig_python.gr_file_source_sptr_seek(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_file_source_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_source_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_source_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_file_source_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_file_source_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_file_source_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_file_source_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_file_source_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_file_source_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_file_source_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_file_source_sptr_set_detail(*args)

gr_file_source_sptr_swigregister = _gnuradio_swig_python.gr_file_source_sptr_swigregister
gr_file_source_sptr_swigregister(gr_file_source_sptr)


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

class gr_file_descriptor_sink_sptr(object):
    """Proxy of C++ gr_file_descriptor_sink_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 __init__(self, *args): 
        """
        __init__(self) -> gr_file_descriptor_sink_sptr
        __init__(self,  p) -> gr_file_descriptor_sink_sptr
        """
        this = _gnuradio_swig_python.new_gr_file_descriptor_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_file_descriptor_sink_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_file_descriptor_sink_sptr_set_detail(*args)

gr_file_descriptor_sink_sptr_swigregister = _gnuradio_swig_python.gr_file_descriptor_sink_sptr_swigregister
gr_file_descriptor_sink_sptr_swigregister(gr_file_descriptor_sink_sptr)

def file_source(*args):
  """
    file_source(size_t itemsize, char filename, bool repeat=False) -> gr_file_source_sptr
    file_source(size_t itemsize, char filename) -> gr_file_source_sptr
    """
  return _gnuradio_swig_python.file_source(*args)


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


def file_descriptor_sink(*args):
  """file_descriptor_sink(size_t itemsize, int fd) -> gr_file_descriptor_sink_sptr"""
  return _gnuradio_swig_python.file_descriptor_sink(*args)
class gr_file_descriptor_source_sptr(object):
    """Proxy of C++ gr_file_descriptor_source_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 __init__(self, *args): 
        """
        __init__(self) -> gr_file_descriptor_source_sptr
        __init__(self,  p) -> gr_file_descriptor_source_sptr
        """
        this = _gnuradio_swig_python.new_gr_file_descriptor_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_file_descriptor_source_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_file_descriptor_source_sptr_set_detail(*args)

gr_file_descriptor_source_sptr_swigregister = _gnuradio_swig_python.gr_file_descriptor_source_sptr_swigregister
gr_file_descriptor_source_sptr_swigregister(gr_file_descriptor_source_sptr)


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

class microtune_xxxx_eval_board(object):
    """Proxy of C++ microtune_xxxx_eval_board class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_microtune_xxxx_eval_board
    __del__ = lambda self : None;
    def board_present_p(*args):
        """board_present_p(self) -> bool"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_board_present_p(*args)

    def set_RF_AGC_voltage(*args):
        """set_RF_AGC_voltage(self, float volts)"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_set_RF_AGC_voltage(*args)

    def set_IF_AGC_voltage(*args):
        """set_IF_AGC_voltage(self, float volts)"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_set_IF_AGC_voltage(*args)

    def set_AGC(*args):
        """set_AGC(self, float value_0_1000)"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_set_AGC(*args)

    def set_RF_freq(*args):
        """set_RF_freq(self, double freq) -> double"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_set_RF_freq(*args)

    def pll_locked_p(*args):
        """pll_locked_p(self) -> bool"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_pll_locked_p(*args)

    def get_output_freq(*args):
        """get_output_freq(self) -> double"""
        return _gnuradio_swig_python.microtune_xxxx_eval_board_get_output_freq(*args)

microtune_xxxx_eval_board_swigregister = _gnuradio_swig_python.microtune_xxxx_eval_board_swigregister
microtune_xxxx_eval_board_swigregister(microtune_xxxx_eval_board)

def file_descriptor_source(*args):
  """
    file_descriptor_source(size_t itemsize, int fd, bool repeat=False) -> gr_file_descriptor_source_sptr
    file_descriptor_source(size_t itemsize, int fd) -> gr_file_descriptor_source_sptr
    """
  return _gnuradio_swig_python.file_descriptor_source(*args)

class microtune_4702_eval_board(microtune_xxxx_eval_board):
    """Proxy of C++ microtune_4702_eval_board class"""
    thisown = _swig_property(lambda 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 which_pp=0) -> microtune_4702_eval_board
        __init__(self) -> microtune_4702_eval_board
        """
        this = _gnuradio_swig_python.new_microtune_4702_eval_board(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_microtune_4702_eval_board
    __del__ = lambda self : None;
microtune_4702_eval_board_swigregister = _gnuradio_swig_python.microtune_4702_eval_board_swigregister
microtune_4702_eval_board_swigregister(microtune_4702_eval_board)

class microtune_4937_eval_board(microtune_xxxx_eval_board):
    """Proxy of C++ microtune_4937_eval_board class"""
    thisown = _swig_property(lambda 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 which_pp=0) -> microtune_4937_eval_board
        __init__(self) -> microtune_4937_eval_board
        """
        this = _gnuradio_swig_python.new_microtune_4937_eval_board(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_microtune_4937_eval_board
    __del__ = lambda self : None;
microtune_4937_eval_board_swigregister = _gnuradio_swig_python.microtune_4937_eval_board_swigregister
microtune_4937_eval_board_swigregister(microtune_4937_eval_board)

class sdr_1000_base(object):
    """Proxy of C++ sdr_1000_base class"""
    thisown = _swig_property(lambda 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 which_pp) -> sdr_1000_base"""
        this = _gnuradio_swig_python.new_sdr_1000_base(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnuradio_swig_python.delete_sdr_1000_base
    __del__ = lambda self : None;
    def reset(*args):
        """reset(self)"""
        return _gnuradio_swig_python.sdr_1000_base_reset(*args)

    def write_latch(*args):
        """write_latch(self, int which, int value, int mask)"""
        return _gnuradio_swig_python.sdr_1000_base_write_latch(*args)

sdr_1000_base_swigregister = _gnuradio_swig_python.sdr_1000_base_swigregister
sdr_1000_base_swigregister(sdr_1000_base)
cvar = _gnuradio_swig_python.cvar
L_EXT = cvar.L_EXT
L_BAND = cvar.L_BAND
L_DDS0 = cvar.L_DDS0
L_DDS1 = cvar.L_DDS1

gr_TRIG_AUTO = _gnuradio_swig_python.gr_TRIG_AUTO
gr_TRIG_POS_SLOPE = _gnuradio_swig_python.gr_TRIG_POS_SLOPE
gr_TRIG_NEG_SLOPE = _gnuradio_swig_python.gr_TRIG_NEG_SLOPE
class gr_oscope_sink_f_sptr(object):
    """Proxy of C++ gr_oscope_sink_f_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 __init__(self, *args): 
        """
        __init__(self) -> gr_oscope_sink_f_sptr
        __init__(self,  p) -> gr_oscope_sink_f_sptr
        """
        this = _gnuradio_swig_python.new_gr_oscope_sink_f_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_oscope_sink_f_sptr
    __del__ = lambda self : None;
    def set_update_rate(*args):
        """set_update_rate(self, double update_rate) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_update_rate(*args)

    def set_decimation_count(*args):
        """set_decimation_count(self, int decimation_count) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_decimation_count(*args)

    def set_trigger_channel(*args):
        """set_trigger_channel(self, int channel) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_trigger_channel(*args)

    def set_trigger_mode(*args):
        """set_trigger_mode(self, gr_trigger_mode mode) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_trigger_mode(*args)

    def set_trigger_level(*args):
        """set_trigger_level(self, double trigger_level) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_trigger_level(*args)

    def set_trigger_level_auto(*args):
        """set_trigger_level_auto(self) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_trigger_level_auto(*args)

    def set_sample_rate(*args):
        """set_sample_rate(self, double sample_rate) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_sample_rate(*args)

    def num_channels(*args):
        """num_channels(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_num_channels(*args)

    def sample_rate(*args):
        """sample_rate(self) -> double"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_sample_rate(*args)

    def update_rate(*args):
        """update_rate(self) -> double"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_update_rate(*args)

    def get_decimation_count(*args):
        """get_decimation_count(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_get_decimation_count(*args)

    def get_trigger_channel(*args):
        """get_trigger_channel(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_get_trigger_channel(*args)

    def get_trigger_mode(*args):
        """get_trigger_mode(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_get_trigger_mode(*args)

    def get_trigger_level(*args):
        """get_trigger_level(self) -> double"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_get_trigger_level(*args)

    def get_samples_per_output_record(*args):
        """get_samples_per_output_record(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_get_samples_per_output_record(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_oscope_sink_f_sptr_set_detail(*args)

gr_oscope_sink_f_sptr_swigregister = _gnuradio_swig_python.gr_oscope_sink_f_sptr_swigregister
gr_oscope_sink_f_sptr_swigregister(gr_oscope_sink_f_sptr)


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


def oscope_sink_f(*args):
  """oscope_sink_f(double sample_rate, gr_msg_queue_sptr msgq) -> gr_oscope_sink_f_sptr"""
  return _gnuradio_swig_python.oscope_sink_f(*args)
class ppio_sptr(object):
    """Proxy of C++ ppio_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 __init__(self, *args): 
        """
        __init__(self) -> ppio_sptr
        __init__(self, ppio p) -> ppio_sptr
        """
        this = _gnuradio_swig_python.new_ppio_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self) -> ppio"""
        return _gnuradio_swig_python.ppio_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_ppio_sptr
    __del__ = lambda self : None;
    def write_data(*args):
        """write_data(self, unsigned char v)"""
        return _gnuradio_swig_python.ppio_sptr_write_data(*args)

    def read_data(*args):
        """read_data(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_sptr_read_data(*args)

    def write_control(*args):
        """write_control(self, unsigned char v)"""
        return _gnuradio_swig_python.ppio_sptr_write_control(*args)

    def read_control(*args):
        """read_control(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_sptr_read_control(*args)

    def read_status(*args):
        """read_status(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_sptr_read_status(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_python.ppio_sptr_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_python.ppio_sptr_unlock(*args)

ppio_sptr_swigregister = _gnuradio_swig_python.ppio_sptr_swigregister
ppio_sptr_swigregister(ppio_sptr)

class ppio(object):
    """Proxy of C++ ppio class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _gnuradio_swig_python.delete_ppio
    __del__ = lambda self : None;
    def write_data(*args):
        """write_data(self, unsigned char v)"""
        return _gnuradio_swig_python.ppio_write_data(*args)

    def read_data(*args):
        """read_data(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_read_data(*args)

    def write_control(*args):
        """write_control(self, unsigned char v)"""
        return _gnuradio_swig_python.ppio_write_control(*args)

    def read_control(*args):
        """read_control(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_read_control(*args)

    def read_status(*args):
        """read_status(self) -> unsigned char"""
        return _gnuradio_swig_python.ppio_read_status(*args)

    def lock(*args):
        """lock(self)"""
        return _gnuradio_swig_python.ppio_lock(*args)

    def unlock(*args):
        """unlock(self)"""
        return _gnuradio_swig_python.ppio_unlock(*args)

ppio_swigregister = _gnuradio_swig_python.ppio_swigregister
ppio_swigregister(ppio)


def make_ppio(*args):
  """make_ppio(int which_pp) -> ppio_sptr"""
  return _gnuradio_swig_python.make_ppio(*args)
class gr_message_source_sptr(object):
    """Proxy of C++ gr_message_source_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 __init__(self, *args): 
        """
        __init__(self) -> gr_message_source_sptr
        __init__(self,  p) -> gr_message_source_sptr
        """
        this = _gnuradio_swig_python.new_gr_message_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_message_source_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_message_source_sptr
    __del__ = lambda self : None;
    def msgq(*args):
        """msgq(self) -> gr_msg_queue_sptr"""
        return _gnuradio_swig_python.gr_message_source_sptr_msgq(*args)

    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_message_source_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_message_source_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_message_source_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_message_source_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_message_source_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_message_source_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_message_source_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_message_source_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_message_source_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_message_source_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_message_source_sptr_set_detail(*args)

gr_message_source_sptr_swigregister = _gnuradio_swig_python.gr_message_source_sptr_swigregister
gr_message_source_sptr_swigregister(gr_message_source_sptr)


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

class gr_message_sink_sptr(object):
    """Proxy of C++ gr_message_sink_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 __init__(self, *args): 
        """
        __init__(self) -> gr_message_sink_sptr
        __init__(self,  p) -> gr_message_sink_sptr
        """
        this = _gnuradio_swig_python.new_gr_message_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(*args):
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_message_sink_sptr___deref__(*args)

    __swig_destroy__ = _gnuradio_swig_python.delete_gr_message_sink_sptr
    __del__ = lambda self : None;
    def name(*args):
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_message_sink_sptr_name(*args)

    def input_signature(*args):
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_message_sink_sptr_input_signature(*args)

    def output_signature(*args):
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_message_sink_sptr_output_signature(*args)

    def unique_id(*args):
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_message_sink_sptr_unique_id(*args)

    def history(*args):
        """history(self) -> unsigned int"""
        return _gnuradio_swig_python.gr_message_sink_sptr_history(*args)

    def output_multiple(*args):
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_message_sink_sptr_output_multiple(*args)

    def relative_rate(*args):
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_message_sink_sptr_relative_rate(*args)

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

    def start(*args):
        """start(self) -> bool"""
        return _gnuradio_swig_python.gr_message_sink_sptr_start(*args)

    def stop(*args):
        """stop(self) -> bool"""
        return _gnuradio_swig_python.gr_message_sink_sptr_stop(*args)

    def detail(*args):
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_message_sink_sptr_detail(*args)

    def set_detail(*args):
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_message_sink_sptr_set_detail(*args)

gr_message_sink_sptr_swigregister = _gnuradio_swig_python.gr_message_sink_sptr_swigregister
gr_message_sink_sptr_swigregister(gr_message_sink_sptr)

def message_source(*args):
  """
    message_source(size_t itemsize, int msgq_limit=0) -> gr_message_source_sptr
    message_source(size_t itemsize) -> gr_message_source_sptr
    """
  return _gnuradio_swig_python.message_source(*args)


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


def message_sink(*args):
  """message_sink(size_t itemsize, gr_msg_queue_sptr msgq, bool dont_block) -> gr_message_sink_sptr"""
  return _gnuradio_swig_python.message_sink(*args)


