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





from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_blocks_swig0', [dirname(__file__)])
        except ImportError:
            import _blocks_swig0
            return _blocks_swig0
        if fp is not None:
            try:
                _mod = imp.load_module('_blocks_swig0', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _blocks_swig0 = swig_import_helper()
    del swig_import_helper
else:
    import _blocks_swig0
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


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


CLOCK_THREAD_CPUTIME_ID = _blocks_swig0.CLOCK_THREAD_CPUTIME_ID

def high_res_timer_now():
  """high_res_timer_now() -> gr::high_res_timer_type"""
  return _blocks_swig0.high_res_timer_now()

def high_res_timer_now_perfmon():
  """high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
  return _blocks_swig0.high_res_timer_now_perfmon()

def high_res_timer_tps():
  """high_res_timer_tps() -> gr::high_res_timer_type"""
  return _blocks_swig0.high_res_timer_tps()

def high_res_timer_epoch():
  """high_res_timer_epoch() -> gr::high_res_timer_type"""
  return _blocks_swig0.high_res_timer_epoch()
class annotator_1to1(object):
    """Proxy of C++ gr::blocks::annotator_1to1 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_make(*args, **kwargs)

    make = staticmethod(make)
    def data(self):
        """data(annotator_1to1 self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_data(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1
    __del__ = lambda self : None;
annotator_1to1_swigregister = _blocks_swig0.annotator_1to1_swigregister
annotator_1to1_swigregister(annotator_1to1)

def annotator_1to1_make(*args, **kwargs):
  """annotator_1to1_make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
  return _blocks_swig0.annotator_1to1_make(*args, **kwargs)

class annotator_alltoall(object):
    """Proxy of C++ gr::blocks::annotator_alltoall class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_make(*args, **kwargs)

    make = staticmethod(make)
    def data(self):
        """data(annotator_alltoall self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_data(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall
    __del__ = lambda self : None;
annotator_alltoall_swigregister = _blocks_swig0.annotator_alltoall_swigregister
annotator_alltoall_swigregister(annotator_alltoall)

def annotator_alltoall_make(*args, **kwargs):
  """annotator_alltoall_make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
  return _blocks_swig0.annotator_alltoall_make(*args, **kwargs)

class annotator_raw(object):
    """Proxy of C++ gr::blocks::annotator_raw class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_make(*args, **kwargs)

    make = staticmethod(make)
    def add_tag(self, *args, **kwargs):
        """add_tag(annotator_raw self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)"""
        return _blocks_swig0.annotator_raw_add_tag(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_annotator_raw
    __del__ = lambda self : None;
annotator_raw_swigregister = _blocks_swig0.annotator_raw_swigregister
annotator_raw_swigregister(annotator_raw)

def annotator_raw_make(*args, **kwargs):
  """annotator_raw_make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
  return _blocks_swig0.annotator_raw_make(*args, **kwargs)

class control_loop(object):
    """Proxy of C++ gr::blocks::control_loop class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(gr::blocks::control_loop self) -> control_loop
        __init__(gr::blocks::control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        this = _blocks_swig0.new_control_loop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _blocks_swig0.delete_control_loop
    __del__ = lambda self : None;
    def update_gains(self):
        """update_gains(control_loop self)"""
        return _blocks_swig0.control_loop_update_gains(self)

    def advance_loop(self, *args, **kwargs):
        """advance_loop(control_loop self, float error)"""
        return _blocks_swig0.control_loop_advance_loop(self, *args, **kwargs)

    def phase_wrap(self):
        """phase_wrap(control_loop self)"""
        return _blocks_swig0.control_loop_phase_wrap(self)

    def frequency_limit(self):
        """frequency_limit(control_loop self)"""
        return _blocks_swig0.control_loop_frequency_limit(self)

    def set_loop_bandwidth(self, *args, **kwargs):
        """set_loop_bandwidth(control_loop self, float bw)"""
        return _blocks_swig0.control_loop_set_loop_bandwidth(self, *args, **kwargs)

    def set_damping_factor(self, *args, **kwargs):
        """set_damping_factor(control_loop self, float df)"""
        return _blocks_swig0.control_loop_set_damping_factor(self, *args, **kwargs)

    def set_alpha(self, *args, **kwargs):
        """set_alpha(control_loop self, float alpha)"""
        return _blocks_swig0.control_loop_set_alpha(self, *args, **kwargs)

    def set_beta(self, *args, **kwargs):
        """set_beta(control_loop self, float beta)"""
        return _blocks_swig0.control_loop_set_beta(self, *args, **kwargs)

    def set_frequency(self, *args, **kwargs):
        """set_frequency(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_frequency(self, *args, **kwargs)

    def set_phase(self, *args, **kwargs):
        """set_phase(control_loop self, float phase)"""
        return _blocks_swig0.control_loop_set_phase(self, *args, **kwargs)

    def set_max_freq(self, *args, **kwargs):
        """set_max_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_max_freq(self, *args, **kwargs)

    def set_min_freq(self, *args, **kwargs):
        """set_min_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_min_freq(self, *args, **kwargs)

    def get_loop_bandwidth(self):
        """get_loop_bandwidth(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_loop_bandwidth(self)

    def get_damping_factor(self):
        """get_damping_factor(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_damping_factor(self)

    def get_alpha(self):
        """get_alpha(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_alpha(self)

    def get_beta(self):
        """get_beta(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_beta(self)

    def get_frequency(self):
        """get_frequency(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_frequency(self)

    def get_phase(self):
        """get_phase(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_phase(self)

    def get_max_freq(self):
        """get_max_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_max_freq(self)

    def get_min_freq(self):
        """get_min_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_min_freq(self)

control_loop_swigregister = _blocks_swig0.control_loop_swigregister
control_loop_swigregister(control_loop)


def tanhf_lut(*args, **kwargs):
  """tanhf_lut(float x) -> float"""
  return _blocks_swig0.tanhf_lut(*args, **kwargs)
class copy(object):
    """Proxy of C++ gr::blocks::copy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_make(*args, **kwargs)

    make = staticmethod(make)
    def set_enabled(self, *args, **kwargs):
        """set_enabled(copy self, bool enable)"""
        return _blocks_swig0.copy_set_enabled(self, *args, **kwargs)

    def enabled(self):
        """enabled(copy self) -> bool"""
        return _blocks_swig0.copy_enabled(self)

    __swig_destroy__ = _blocks_swig0.delete_copy
    __del__ = lambda self : None;
copy_swigregister = _blocks_swig0.copy_swigregister
copy_swigregister(copy)
cvar = _blocks_swig0.cvar

def copy_make(*args, **kwargs):
  """copy_make(size_t itemsize) -> copy_sptr"""
  return _blocks_swig0.copy_make(*args, **kwargs)

class delay(object):
    """Proxy of C++ gr::blocks::delay class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_make(*args, **kwargs)

    make = staticmethod(make)
    def dly(self):
        """dly(delay self) -> int"""
        return _blocks_swig0.delay_dly(self)

    def set_dly(self, *args, **kwargs):
        """set_dly(delay self, int d)"""
        return _blocks_swig0.delay_set_dly(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_delay
    __del__ = lambda self : None;
delay_swigregister = _blocks_swig0.delay_swigregister
delay_swigregister(delay)

def delay_make(*args, **kwargs):
  """delay_make(size_t itemsize, int delay) -> delay_sptr"""
  return _blocks_swig0.delay_make(*args, **kwargs)

class endian_swap(object):
    """Proxy of C++ gr::blocks::endian_swap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(item_size_bytes=1):
        """make(size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_make(item_size_bytes)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_endian_swap
    __del__ = lambda self : None;
endian_swap_swigregister = _blocks_swig0.endian_swap_swigregister
endian_swap_swigregister(endian_swap)

def endian_swap_make(item_size_bytes=1):
  """endian_swap_make(size_t item_size_bytes=1) -> endian_swap_sptr"""
  return _blocks_swig0.endian_swap_make(item_size_bytes)

class file_descriptor_sink(object):
    """Proxy of C++ gr::blocks::file_descriptor_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink
    __del__ = lambda self : None;
file_descriptor_sink_swigregister = _blocks_swig0.file_descriptor_sink_swigregister
file_descriptor_sink_swigregister(file_descriptor_sink)

def file_descriptor_sink_make(*args, **kwargs):
  """file_descriptor_sink_make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
  return _blocks_swig0.file_descriptor_sink_make(*args, **kwargs)

class file_descriptor_source(object):
    """Proxy of C++ gr::blocks::file_descriptor_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source
    __del__ = lambda self : None;
file_descriptor_source_swigregister = _blocks_swig0.file_descriptor_source_swigregister
file_descriptor_source_swigregister(file_descriptor_source)

def file_descriptor_source_make(*args, **kwargs):
  """file_descriptor_source_make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
  return _blocks_swig0.file_descriptor_source_make(*args, **kwargs)

class file_sink_base(object):
    """Proxy of C++ gr::blocks::file_sink_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): 
        """__init__(gr::blocks::file_sink_base self) -> file_sink_base"""
        this = _blocks_swig0.new_file_sink_base()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _blocks_swig0.delete_file_sink_base
    __del__ = lambda self : None;
    def open(self, *args, **kwargs):
        """open(file_sink_base self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_base_open(self, *args, **kwargs)

    def close(self):
        """close(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_close(self)

    def do_update(self):
        """do_update(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_do_update(self)

    def set_unbuffered(self, *args, **kwargs):
        """set_unbuffered(file_sink_base self, bool unbuffered)"""
        return _blocks_swig0.file_sink_base_set_unbuffered(self, *args, **kwargs)

file_sink_base_swigregister = _blocks_swig0.file_sink_base_swigregister
file_sink_base_swigregister(file_sink_base)

class file_sink(file_sink_base):
    """Proxy of C++ gr::blocks::file_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_sink
    __del__ = lambda self : None;
file_sink_swigregister = _blocks_swig0.file_sink_swigregister
file_sink_swigregister(file_sink)

def file_sink_make(*args, **kwargs):
  """file_sink_make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
  return _blocks_swig0.file_sink_make(*args, **kwargs)

class file_source(object):
    """Proxy of C++ gr::blocks::file_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
        return _blocks_swig0.file_source_make(*args, **kwargs)

    make = staticmethod(make)
    def seek(self, *args, **kwargs):
        """seek(file_source self, long seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_seek(self, *args, **kwargs)

    def open(self, *args, **kwargs):
        """open(file_source self, char const * filename, bool repeat)"""
        return _blocks_swig0.file_source_open(self, *args, **kwargs)

    def close(self):
        """close(file_source self)"""
        return _blocks_swig0.file_source_close(self)

    def set_begin_tag(self, *args, **kwargs):
        """set_begin_tag(file_source self, swig_int_ptr val)"""
        return _blocks_swig0.file_source_set_begin_tag(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_file_source
    __del__ = lambda self : None;
file_source_swigregister = _blocks_swig0.file_source_swigregister
file_source_swigregister(file_source)

def file_source_make(*args, **kwargs):
  """file_source_make(size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
  return _blocks_swig0.file_source_make(*args, **kwargs)

GR_FILE_BYTE = _blocks_swig0.GR_FILE_BYTE
GR_FILE_CHAR = _blocks_swig0.GR_FILE_CHAR
GR_FILE_SHORT = _blocks_swig0.GR_FILE_SHORT
GR_FILE_INT = _blocks_swig0.GR_FILE_INT
GR_FILE_LONG = _blocks_swig0.GR_FILE_LONG
GR_FILE_LONG_LONG = _blocks_swig0.GR_FILE_LONG_LONG
GR_FILE_FLOAT = _blocks_swig0.GR_FILE_FLOAT
GR_FILE_DOUBLE = _blocks_swig0.GR_FILE_DOUBLE
class file_meta_sink(object):
    """Proxy of C++ gr::blocks::file_meta_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """
        make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, 
            gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, 
            size_t max_segment_size=1000000, std::string const & extra_dict="", bool detached_header=False) -> file_meta_sink_sptr
        """
        return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

    make = staticmethod(make)
    def open(self, *args, **kwargs):
        """open(file_meta_sink self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_open(self, *args, **kwargs)

    def close(self):
        """close(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_close(self)

    def do_update(self):
        """do_update(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_do_update(self)

    def set_unbuffered(self, *args, **kwargs):
        """set_unbuffered(file_meta_sink self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_set_unbuffered(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink
    __del__ = lambda self : None;
file_meta_sink_swigregister = _blocks_swig0.file_meta_sink_swigregister
file_meta_sink_swigregister(file_meta_sink)
METADATA_VERSION = cvar.METADATA_VERSION
METADATA_HEADER_SIZE = cvar.METADATA_HEADER_SIZE

def file_meta_sink_make(*args, **kwargs):
  """
    file_meta_sink_make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, 
        gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, 
        size_t max_segment_size=1000000, std::string const & extra_dict="", bool detached_header=False) -> file_meta_sink_sptr
    """
  return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

class file_meta_source(object):
    """Proxy of C++ gr::blocks::file_meta_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_make(*args, **kwargs)

    make = staticmethod(make)
    def open(self, *args, **kwargs):
        """open(file_meta_source self, std::string const & filename, std::string const & hdr_filename="") -> bool"""
        return _blocks_swig0.file_meta_source_open(self, *args, **kwargs)

    def close(self):
        """close(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_close(self)

    def do_update(self):
        """do_update(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_do_update(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_source
    __del__ = lambda self : None;
file_meta_source_swigregister = _blocks_swig0.file_meta_source_swigregister
file_meta_source_swigregister(file_meta_source)

def file_meta_source_make(*args, **kwargs):
  """file_meta_source_make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
  return _blocks_swig0.file_meta_source_make(*args, **kwargs)

class head(object):
    """Proxy of C++ gr::blocks::head class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_make(*args, **kwargs)

    make = staticmethod(make)
    def reset(self):
        """reset(head self)"""
        return _blocks_swig0.head_reset(self)

    def set_length(self, *args, **kwargs):
        """set_length(head self, uint64_t nitems)"""
        return _blocks_swig0.head_set_length(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_head
    __del__ = lambda self : None;
head_swigregister = _blocks_swig0.head_swigregister
head_swigregister(head)

def head_make(*args, **kwargs):
  """head_make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
  return _blocks_swig0.head_make(*args, **kwargs)

class message_debug(object):
    """Proxy of C++ gr::blocks::message_debug class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make():
        """make() -> message_debug_sptr"""
        return _blocks_swig0.message_debug_make()

    make = staticmethod(make)
    def num_messages(self):
        """num_messages(message_debug self) -> int"""
        return _blocks_swig0.message_debug_num_messages(self)

    def get_message(self, *args, **kwargs):
        """get_message(message_debug self, int i) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_get_message(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_message_debug
    __del__ = lambda self : None;
message_debug_swigregister = _blocks_swig0.message_debug_swigregister
message_debug_swigregister(message_debug)

def message_debug_make():
  """message_debug_make() -> message_debug_sptr"""
  return _blocks_swig0.message_debug_make()

class message_sink(object):
    """Proxy of C++ gr::blocks::message_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(*args):
        """
        make(size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
        make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
        """
        return _blocks_swig0.message_sink_make(*args)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_message_sink
    __del__ = lambda self : None;
message_sink_swigregister = _blocks_swig0.message_sink_swigregister
message_sink_swigregister(message_sink)

def message_sink_make(*args):
  """
    make(size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
    message_sink_make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
    """
  return _blocks_swig0.message_sink_make(*args)

class message_source(object):
    """Proxy of C++ gr::blocks::message_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args):
        """
        make(size_t itemsize, int msgq_limit=0) -> message_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
        """
        return _blocks_swig0.message_source_make(*args)

    make = staticmethod(make)
    def msgq(self):
        """msgq(message_source self) -> msg_queue_sptr"""
        return _blocks_swig0.message_source_msgq(self)

    __swig_destroy__ = _blocks_swig0.delete_message_source
    __del__ = lambda self : None;
message_source_swigregister = _blocks_swig0.message_source_swigregister
message_source_swigregister(message_source)

def message_source_make(*args):
  """
    make(size_t itemsize, int msgq_limit=0) -> message_source_sptr
    make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
    message_source_make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
    """
  return _blocks_swig0.message_source_make(*args)

class message_strobe(object):
    """Proxy of C++ gr::blocks::message_strobe class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_make(*args, **kwargs)

    make = staticmethod(make)
    def set_msg(self, *args, **kwargs):
        """set_msg(message_strobe self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_set_msg(self, *args, **kwargs)

    def msg(self):
        """msg(message_strobe self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_msg(self)

    def set_period(self, *args, **kwargs):
        """set_period(message_strobe self, float period_ms)"""
        return _blocks_swig0.message_strobe_set_period(self, *args, **kwargs)

    def period(self):
        """period(message_strobe self) -> float"""
        return _blocks_swig0.message_strobe_period(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe
    __del__ = lambda self : None;
message_strobe_swigregister = _blocks_swig0.message_strobe_swigregister
message_strobe_swigregister(message_strobe)

def message_strobe_make(*args, **kwargs):
  """message_strobe_make(swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
  return _blocks_swig0.message_strobe_make(*args, **kwargs)

STROBE_POISSON = _blocks_swig0.STROBE_POISSON
STROBE_GAUSSIAN = _blocks_swig0.STROBE_GAUSSIAN
STROBE_UNIFORM = _blocks_swig0.STROBE_UNIFORM
class message_strobe_random(object):
    """Proxy of C++ gr::blocks::message_strobe_random class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """
        make(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, 
            float std_ms) -> message_strobe_random_sptr
        """
        return _blocks_swig0.message_strobe_random_make(*args, **kwargs)

    make = staticmethod(make)
    def set_msg(self, *args, **kwargs):
        """set_msg(message_strobe_random self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_set_msg(self, *args, **kwargs)

    def msg(self):
        """msg(message_strobe_random self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_msg(self)

    def set_dist(self, *args, **kwargs):
        """set_dist(message_strobe_random self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_set_dist(self, *args, **kwargs)

    def dist(self):
        """dist(message_strobe_random self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_dist(self)

    def set_mean(self, *args, **kwargs):
        """set_mean(message_strobe_random self, float mean)"""
        return _blocks_swig0.message_strobe_random_set_mean(self, *args, **kwargs)

    def mean(self):
        """mean(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_mean(self)

    def set_std(self, *args, **kwargs):
        """set_std(message_strobe_random self, float std)"""
        return _blocks_swig0.message_strobe_random_set_std(self, *args, **kwargs)

    def std(self):
        """std(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_std(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random
    __del__ = lambda self : None;
message_strobe_random_swigregister = _blocks_swig0.message_strobe_random_swigregister
message_strobe_random_swigregister(message_strobe_random)

def message_strobe_random_make(*args, **kwargs):
  """
    message_strobe_random_make(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, 
        float std_ms) -> message_strobe_random_sptr
    """
  return _blocks_swig0.message_strobe_random_make(*args, **kwargs)

class message_burst_source(object):
    """Proxy of C++ gr::blocks::message_burst_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args):
        """
        make(size_t itemsize, int msgq_limit) -> message_burst_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
        """
        return _blocks_swig0.message_burst_source_make(*args)

    make = staticmethod(make)
    def msgq(self):
        """msgq(message_burst_source self) -> msg_queue_sptr"""
        return _blocks_swig0.message_burst_source_msgq(self)

    __swig_destroy__ = _blocks_swig0.delete_message_burst_source
    __del__ = lambda self : None;
message_burst_source_swigregister = _blocks_swig0.message_burst_source_swigregister
message_burst_source_swigregister(message_burst_source)

def message_burst_source_make(*args):
  """
    make(size_t itemsize, int msgq_limit) -> message_burst_source_sptr
    message_burst_source_make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
    """
  return _blocks_swig0.message_burst_source_make(*args)

class nop(object):
    """Proxy of C++ gr::blocks::nop class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_make(*args, **kwargs)

    make = staticmethod(make)
    def nmsgs_received(self):
        """nmsgs_received(nop self) -> int"""
        return _blocks_swig0.nop_nmsgs_received(self)

    def ctrlport_test(self):
        """ctrlport_test(nop self) -> int"""
        return _blocks_swig0.nop_ctrlport_test(self)

    def set_ctrlport_test(self, *args, **kwargs):
        """set_ctrlport_test(nop self, int x)"""
        return _blocks_swig0.nop_set_ctrlport_test(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig0.delete_nop
    __del__ = lambda self : None;
nop_swigregister = _blocks_swig0.nop_swigregister
nop_swigregister(nop)

def nop_make(*args, **kwargs):
  """nop_make(size_t sizeof_stream_item) -> nop_sptr"""
  return _blocks_swig0.nop_make(*args, **kwargs)

class null_sink(object):
    """Proxy of C++ gr::blocks::null_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_null_sink
    __del__ = lambda self : None;
null_sink_swigregister = _blocks_swig0.null_sink_swigregister
null_sink_swigregister(null_sink)

def null_sink_make(*args, **kwargs):
  """null_sink_make(size_t sizeof_stream_item) -> null_sink_sptr"""
  return _blocks_swig0.null_sink_make(*args, **kwargs)

class null_source(object):
    """Proxy of C++ gr::blocks::null_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_null_source
    __del__ = lambda self : None;
null_source_swigregister = _blocks_swig0.null_source_swigregister
null_source_swigregister(null_source)

def null_source_make(*args, **kwargs):
  """null_source_make(size_t sizeof_stream_item) -> null_source_sptr"""
  return _blocks_swig0.null_source_make(*args, **kwargs)

class annotator_1to1_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_1to1)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::annotator_1to1)> self) -> annotator_1to1_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_1to1)> self, annotator_1to1 p) -> annotator_1to1_sptr
        """
        this = _blocks_swig0.new_annotator_1to1_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(annotator_1to1_sptr self) -> annotator_1to1"""
        return _blocks_swig0.annotator_1to1_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(annotator_1to1_sptr self, int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_make(self, *args, **kwargs)

    def data(self):
        """data(annotator_1to1_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_sptr_data(self)

    def history(self):
        """history(annotator_1to1_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_1to1_sptr self, int which, int delay)
        declare_sample_delay(annotator_1to1_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_1to1_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(annotator_1to1_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(annotator_1to1_sptr self) -> double"""
        return _blocks_swig0.annotator_1to1_sptr_relative_rate(self)

    def start(self):
        """start(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_start(self)

    def stop(self):
        """stop(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(annotator_1to1_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(annotator_1to1_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_1to1_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_1to1_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_1to1_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_1to1_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(annotator_1to1_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_1to1_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(annotator_1to1_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_1to1_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(annotator_1to1_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_name(self)

    def symbol_name(self):
        """symbol_name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(annotator_1to1_sptr self) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(annotator_1to1_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(annotator_1to1_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(annotator_1to1_sptr self, std::string name)"""
        return _blocks_swig0.annotator_1to1_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(annotator_1to1_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_1to1_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(annotator_1to1_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(annotator_1to1_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(annotator_1to1_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_subscribers(self, *args, **kwargs)

annotator_1to1_sptr_swigregister = _blocks_swig0.annotator_1to1_sptr_swigregister
annotator_1to1_sptr_swigregister(annotator_1to1_sptr)

annotator_1to1_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
annotator_1to1 = annotator_1to1.make;

class annotator_alltoall_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_alltoall)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::annotator_alltoall)> self) -> annotator_alltoall_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_alltoall)> self, annotator_alltoall p) -> annotator_alltoall_sptr
        """
        this = _blocks_swig0.new_annotator_alltoall_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(annotator_alltoall_sptr self) -> annotator_alltoall"""
        return _blocks_swig0.annotator_alltoall_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(annotator_alltoall_sptr self, int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_make(self, *args, **kwargs)

    def data(self):
        """data(annotator_alltoall_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_sptr_data(self)

    def history(self):
        """history(annotator_alltoall_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_alltoall_sptr self, int which, int delay)
        declare_sample_delay(annotator_alltoall_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_alltoall_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(annotator_alltoall_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(annotator_alltoall_sptr self) -> double"""
        return _blocks_swig0.annotator_alltoall_sptr_relative_rate(self)

    def start(self):
        """start(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_start(self)

    def stop(self):
        """stop(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(annotator_alltoall_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(annotator_alltoall_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_alltoall_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_alltoall_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_alltoall_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_alltoall_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(annotator_alltoall_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(annotator_alltoall_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_alltoall_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(annotator_alltoall_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_name(self)

    def symbol_name(self):
        """symbol_name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(annotator_alltoall_sptr self) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(annotator_alltoall_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(annotator_alltoall_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(annotator_alltoall_sptr self, std::string name)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(annotator_alltoall_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_alltoall_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(annotator_alltoall_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(annotator_alltoall_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(annotator_alltoall_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_subscribers(self, *args, **kwargs)

annotator_alltoall_sptr_swigregister = _blocks_swig0.annotator_alltoall_sptr_swigregister
annotator_alltoall_sptr_swigregister(annotator_alltoall_sptr)

annotator_alltoall_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
annotator_alltoall = annotator_alltoall.make;

class annotator_raw_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_raw)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::annotator_raw)> self) -> annotator_raw_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_raw)> self, annotator_raw p) -> annotator_raw_sptr
        """
        this = _blocks_swig0.new_annotator_raw_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(annotator_raw_sptr self) -> annotator_raw"""
        return _blocks_swig0.annotator_raw_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_raw_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(annotator_raw_sptr self, size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_sptr_make(self, *args, **kwargs)

    def add_tag(self, *args, **kwargs):
        """add_tag(annotator_raw_sptr self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)"""
        return _blocks_swig0.annotator_raw_sptr_add_tag(self, *args, **kwargs)

    def history(self):
        """history(annotator_raw_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_raw_sptr self, int which, int delay)
        declare_sample_delay(annotator_raw_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_raw_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(annotator_raw_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(annotator_raw_sptr self) -> double"""
        return _blocks_swig0.annotator_raw_sptr_relative_rate(self)

    def start(self):
        """start(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_start(self)

    def stop(self):
        """stop(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(annotator_raw_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(annotator_raw_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_raw_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_raw_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_raw_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_raw_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(annotator_raw_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_raw_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(annotator_raw_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_raw_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(annotator_raw_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_raw_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_name(self)

    def symbol_name(self):
        """symbol_name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(annotator_raw_sptr self) -> long"""
        return _blocks_swig0.annotator_raw_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(annotator_raw_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_raw_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(annotator_raw_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(annotator_raw_sptr self, std::string name)"""
        return _blocks_swig0.annotator_raw_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(annotator_raw_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_raw_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(annotator_raw_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(annotator_raw_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(annotator_raw_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_subscribers(self, *args, **kwargs)

annotator_raw_sptr_swigregister = _blocks_swig0.annotator_raw_sptr_swigregister
annotator_raw_sptr_swigregister(annotator_raw_sptr)

annotator_raw_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
annotator_raw = annotator_raw.make;

class copy_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::copy)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::copy)> self) -> copy_sptr
        __init__(boost::shared_ptr<(gr::blocks::copy)> self, copy p) -> copy_sptr
        """
        this = _blocks_swig0.new_copy_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(copy_sptr self) -> copy"""
        return _blocks_swig0.copy_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_copy_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(copy_sptr self, size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_sptr_make(self, *args, **kwargs)

    def set_enabled(self, *args, **kwargs):
        """set_enabled(copy_sptr self, bool enable)"""
        return _blocks_swig0.copy_sptr_set_enabled(self, *args, **kwargs)

    def enabled(self):
        """enabled(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_enabled(self)

    def history(self):
        """history(copy_sptr self) -> unsigned int"""
        return _blocks_swig0.copy_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(copy_sptr self, int which, int delay)
        declare_sample_delay(copy_sptr self, unsigned int delay)
        """
        return _blocks_swig0.copy_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(copy_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.copy_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(copy_sptr self) -> double"""
        return _blocks_swig0.copy_sptr_relative_rate(self)

    def start(self):
        """start(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_start(self)

    def stop(self):
        """stop(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(copy_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(copy_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(copy_sptr self, long max_output_buffer)
        set_max_output_buffer(copy_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(copy_sptr self, long min_output_buffer)
        set_min_output_buffer(copy_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(copy_sptr self, int which) -> float
        pc_input_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(copy_sptr self, int which) -> float
        pc_input_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(copy_sptr self, int which) -> float
        pc_input_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(copy_sptr self, int which) -> float
        pc_output_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(copy_sptr self, int which) -> float
        pc_output_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(copy_sptr self, int which) -> float
        pc_output_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(copy_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.copy_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(copy_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.copy_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(copy_sptr self, int priority) -> int"""
        return _blocks_swig0.copy_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_name(self)

    def symbol_name(self):
        """symbol_name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(copy_sptr self) -> long"""
        return _blocks_swig0.copy_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(copy_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.copy_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(copy_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.copy_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(copy_sptr self, std::string name)"""
        return _blocks_swig0.copy_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(copy_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.copy_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(copy_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(copy_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(copy_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_subscribers(self, *args, **kwargs)

copy_sptr_swigregister = _blocks_swig0.copy_sptr_swigregister
copy_sptr_swigregister(copy_sptr)

copy_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
copy = copy.make;

class delay_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::delay)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::delay)> self) -> delay_sptr
        __init__(boost::shared_ptr<(gr::blocks::delay)> self, delay p) -> delay_sptr
        """
        this = _blocks_swig0.new_delay_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(delay_sptr self) -> delay"""
        return _blocks_swig0.delay_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_delay_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(delay_sptr self, size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_sptr_make(self, *args, **kwargs)

    def dly(self):
        """dly(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_dly(self)

    def set_dly(self, *args, **kwargs):
        """set_dly(delay_sptr self, int d)"""
        return _blocks_swig0.delay_sptr_set_dly(self, *args, **kwargs)

    def history(self):
        """history(delay_sptr self) -> unsigned int"""
        return _blocks_swig0.delay_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(delay_sptr self, int which, int delay)
        declare_sample_delay(delay_sptr self, unsigned int delay)
        """
        return _blocks_swig0.delay_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(delay_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.delay_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(delay_sptr self) -> double"""
        return _blocks_swig0.delay_sptr_relative_rate(self)

    def start(self):
        """start(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_start(self)

    def stop(self):
        """stop(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(delay_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(delay_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(delay_sptr self, long max_output_buffer)
        set_max_output_buffer(delay_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(delay_sptr self, long min_output_buffer)
        set_min_output_buffer(delay_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(delay_sptr self, int which) -> float
        pc_input_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(delay_sptr self, int which) -> float
        pc_input_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(delay_sptr self, int which) -> float
        pc_input_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(delay_sptr self, int which) -> float
        pc_output_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(delay_sptr self, int which) -> float
        pc_output_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(delay_sptr self, int which) -> float
        pc_output_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(delay_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.delay_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(delay_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.delay_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(delay_sptr self, int priority) -> int"""
        return _blocks_swig0.delay_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_name(self)

    def symbol_name(self):
        """symbol_name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(delay_sptr self) -> long"""
        return _blocks_swig0.delay_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(delay_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.delay_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(delay_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.delay_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(delay_sptr self, std::string name)"""
        return _blocks_swig0.delay_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(delay_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.delay_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(delay_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(delay_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(delay_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_subscribers(self, *args, **kwargs)

delay_sptr_swigregister = _blocks_swig0.delay_sptr_swigregister
delay_sptr_swigregister(delay_sptr)

delay_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
delay = delay.make;

class endian_swap_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::endian_swap)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::endian_swap)> self) -> endian_swap_sptr
        __init__(boost::shared_ptr<(gr::blocks::endian_swap)> self, endian_swap p) -> endian_swap_sptr
        """
        this = _blocks_swig0.new_endian_swap_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(endian_swap_sptr self) -> endian_swap"""
        return _blocks_swig0.endian_swap_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_endian_swap_sptr
    __del__ = lambda self : None;
    def make(self, item_size_bytes=1):
        """make(endian_swap_sptr self, size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_sptr_make(self, item_size_bytes)

    def history(self):
        """history(endian_swap_sptr self) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(endian_swap_sptr self, int which, int delay)
        declare_sample_delay(endian_swap_sptr self, unsigned int delay)
        """
        return _blocks_swig0.endian_swap_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(endian_swap_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(endian_swap_sptr self) -> double"""
        return _blocks_swig0.endian_swap_sptr_relative_rate(self)

    def start(self):
        """start(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_start(self)

    def stop(self):
        """stop(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(endian_swap_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(endian_swap_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(endian_swap_sptr self, long max_output_buffer)
        set_max_output_buffer(endian_swap_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(endian_swap_sptr self, long min_output_buffer)
        set_min_output_buffer(endian_swap_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(endian_swap_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.endian_swap_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(endian_swap_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.endian_swap_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(endian_swap_sptr self, int priority) -> int"""
        return _blocks_swig0.endian_swap_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_name(self)

    def symbol_name(self):
        """symbol_name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(endian_swap_sptr self) -> long"""
        return _blocks_swig0.endian_swap_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(endian_swap_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.endian_swap_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(endian_swap_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.endian_swap_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(endian_swap_sptr self, std::string name)"""
        return _blocks_swig0.endian_swap_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(endian_swap_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.endian_swap_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(endian_swap_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(endian_swap_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(endian_swap_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_subscribers(self, *args, **kwargs)

endian_swap_sptr_swigregister = _blocks_swig0.endian_swap_sptr_swigregister
endian_swap_sptr_swigregister(endian_swap_sptr)

endian_swap_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
endian_swap = endian_swap.make;

class file_descriptor_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_descriptor_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_sink)> self) -> file_descriptor_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_sink)> self, file_descriptor_sink p) -> file_descriptor_sink_sptr
        """
        this = _blocks_swig0.new_file_descriptor_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_descriptor_sink_sptr self) -> file_descriptor_sink"""
        return _blocks_swig0.file_descriptor_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(file_descriptor_sink_sptr self, size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_make(self, *args, **kwargs)

    def history(self):
        """history(file_descriptor_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_descriptor_sink_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_descriptor_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_descriptor_sink_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_sink_sptr_relative_rate(self)

    def start(self):
        """start(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_start(self)

    def stop(self):
        """stop(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_descriptor_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_descriptor_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_descriptor_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_descriptor_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_descriptor_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_descriptor_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_sink_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_descriptor_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_descriptor_sink_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_descriptor_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_descriptor_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_descriptor_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_descriptor_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_descriptor_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_descriptor_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_descriptor_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_descriptor_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_subscribers(self, *args, **kwargs)

file_descriptor_sink_sptr_swigregister = _blocks_swig0.file_descriptor_sink_sptr_swigregister
file_descriptor_sink_sptr_swigregister(file_descriptor_sink_sptr)

file_descriptor_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_descriptor_sink = file_descriptor_sink.make;

class file_descriptor_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_descriptor_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_source)> self) -> file_descriptor_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_source)> self, file_descriptor_source p) -> file_descriptor_source_sptr
        """
        this = _blocks_swig0.new_file_descriptor_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_descriptor_source_sptr self) -> file_descriptor_source"""
        return _blocks_swig0.file_descriptor_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(file_descriptor_source_sptr self, size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_make(self, *args, **kwargs)

    def history(self):
        """history(file_descriptor_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_descriptor_source_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_descriptor_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_descriptor_source_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_source_sptr_relative_rate(self)

    def start(self):
        """start(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_start(self)

    def stop(self):
        """stop(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_descriptor_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_descriptor_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_descriptor_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_descriptor_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_descriptor_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_descriptor_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_descriptor_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_descriptor_source_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_descriptor_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_descriptor_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_descriptor_source_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_descriptor_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_descriptor_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_descriptor_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_descriptor_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_descriptor_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_subscribers(self, *args, **kwargs)

file_descriptor_source_sptr_swigregister = _blocks_swig0.file_descriptor_source_sptr_swigregister
file_descriptor_source_sptr_swigregister(file_descriptor_source_sptr)

file_descriptor_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_descriptor_source = file_descriptor_source.make;

class file_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_sink)> self) -> file_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_sink)> self, file_sink p) -> file_sink_sptr
        """
        this = _blocks_swig0.new_file_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_sink_sptr self) -> file_sink"""
        return _blocks_swig0.file_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(file_sink_sptr self, size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_sptr_make(self, *args, **kwargs)

    def history(self):
        """history(file_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_sink_sptr self, int which, int delay)
        declare_sample_delay(file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_sink_sptr self) -> double"""
        return _blocks_swig0.file_sink_sptr_relative_rate(self)

    def start(self):
        """start(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_start(self)

    def stop(self):
        """stop(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_sink_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_sink_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_sink_sptr self) -> long"""
        return _blocks_swig0.file_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_subscribers(self, *args, **kwargs)

    def open(self, *args, **kwargs):
        """open(file_sink_sptr self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_sptr_open(self, *args, **kwargs)

    def close(self):
        """close(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_close(self)

    def do_update(self):
        """do_update(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_do_update(self)

    def set_unbuffered(self, *args, **kwargs):
        """set_unbuffered(file_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_sink_sptr_set_unbuffered(self, *args, **kwargs)

file_sink_sptr_swigregister = _blocks_swig0.file_sink_sptr_swigregister
file_sink_sptr_swigregister(file_sink_sptr)

file_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_sink = file_sink.make;

class file_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_source)> self) -> file_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_source)> self, file_source p) -> file_source_sptr
        """
        this = _blocks_swig0.new_file_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_source_sptr self) -> file_source"""
        return _blocks_swig0.file_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_source_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(file_source_sptr self, size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
        return _blocks_swig0.file_source_sptr_make(self, *args, **kwargs)

    def seek(self, *args, **kwargs):
        """seek(file_source_sptr self, long seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_sptr_seek(self, *args, **kwargs)

    def open(self, *args, **kwargs):
        """open(file_source_sptr self, char const * filename, bool repeat)"""
        return _blocks_swig0.file_source_sptr_open(self, *args, **kwargs)

    def close(self):
        """close(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_close(self)

    def set_begin_tag(self, *args, **kwargs):
        """set_begin_tag(file_source_sptr self, swig_int_ptr val)"""
        return _blocks_swig0.file_source_sptr_set_begin_tag(self, *args, **kwargs)

    def history(self):
        """history(file_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_source_sptr self, int which, int delay)
        declare_sample_delay(file_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_source_sptr self) -> double"""
        return _blocks_swig0.file_source_sptr_relative_rate(self)

    def start(self):
        """start(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_start(self)

    def stop(self):
        """stop(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_source_sptr self, int which) -> float
        pc_input_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_source_sptr self, int which) -> float
        pc_output_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_source_sptr self) -> long"""
        return _blocks_swig0.file_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_source_sptr self, std::string name)"""
        return _blocks_swig0.file_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_subscribers(self, *args, **kwargs)

file_source_sptr_swigregister = _blocks_swig0.file_source_sptr_swigregister
file_source_sptr_swigregister(file_source_sptr)

file_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_source = file_source.make;

class file_meta_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_meta_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_meta_sink)> self) -> file_meta_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_meta_sink)> self, file_meta_sink p) -> file_meta_sink_sptr
        """
        this = _blocks_swig0.new_file_meta_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_meta_sink_sptr self) -> file_meta_sink"""
        return _blocks_swig0.file_meta_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """
        make(file_meta_sink_sptr self, size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, 
            gr::blocks::gr_file_types type=GR_FILE_FLOAT, bool complex=True, 
            size_t max_segment_size=1000000, std::string const & extra_dict="", bool detached_header=False) -> file_meta_sink_sptr
        """
        return _blocks_swig0.file_meta_sink_sptr_make(self, *args, **kwargs)

    def open(self, *args, **kwargs):
        """open(file_meta_sink_sptr self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_open(self, *args, **kwargs)

    def close(self):
        """close(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_close(self)

    def do_update(self):
        """do_update(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_do_update(self)

    def set_unbuffered(self, *args, **kwargs):
        """set_unbuffered(file_meta_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_sptr_set_unbuffered(self, *args, **kwargs)

    def history(self):
        """history(file_meta_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_meta_sink_sptr self, int which, int delay)
        declare_sample_delay(file_meta_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_meta_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_meta_sink_sptr self) -> double"""
        return _blocks_swig0.file_meta_sink_sptr_relative_rate(self)

    def start(self):
        """start(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_start(self)

    def stop(self):
        """stop(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_meta_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_meta_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_meta_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_meta_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_meta_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_sink_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_meta_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_sink_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_meta_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_meta_sink_sptr self) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_meta_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_meta_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_meta_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_meta_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_meta_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_meta_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_meta_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_meta_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_subscribers(self, *args, **kwargs)

file_meta_sink_sptr_swigregister = _blocks_swig0.file_meta_sink_sptr_swigregister
file_meta_sink_sptr_swigregister(file_meta_sink_sptr)

file_meta_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_meta_sink = file_meta_sink.make;

class file_meta_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_meta_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::file_meta_source)> self) -> file_meta_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_meta_source)> self, file_meta_source p) -> file_meta_source_sptr
        """
        this = _blocks_swig0.new_file_meta_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(file_meta_source_sptr self) -> file_meta_source"""
        return _blocks_swig0.file_meta_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_source_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(file_meta_source_sptr self, std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename="") -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_sptr_make(self, *args, **kwargs)

    def open(self, *args, **kwargs):
        """open(file_meta_source_sptr self, std::string const & filename, std::string const & hdr_filename="") -> bool"""
        return _blocks_swig0.file_meta_source_sptr_open(self, *args, **kwargs)

    def close(self):
        """close(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_close(self)

    def do_update(self):
        """do_update(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_do_update(self)

    def history(self):
        """history(file_meta_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_meta_source_sptr self, int which, int delay)
        declare_sample_delay(file_meta_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(file_meta_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(file_meta_source_sptr self) -> double"""
        return _blocks_swig0.file_meta_source_sptr_relative_rate(self)

    def start(self):
        """start(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_start(self)

    def stop(self):
        """stop(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(file_meta_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(file_meta_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_meta_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_meta_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(file_meta_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(file_meta_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(file_meta_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(file_meta_source_sptr self) -> long"""
        return _blocks_swig0.file_meta_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(file_meta_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(file_meta_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(file_meta_source_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(file_meta_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_meta_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(file_meta_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(file_meta_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(file_meta_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_subscribers(self, *args, **kwargs)

file_meta_source_sptr_swigregister = _blocks_swig0.file_meta_source_sptr_swigregister
file_meta_source_sptr_swigregister(file_meta_source_sptr)

file_meta_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
file_meta_source = file_meta_source.make;

class head_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::head)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::head)> self) -> head_sptr
        __init__(boost::shared_ptr<(gr::blocks::head)> self, head p) -> head_sptr
        """
        this = _blocks_swig0.new_head_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(head_sptr self) -> head"""
        return _blocks_swig0.head_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_head_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(head_sptr self, size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_sptr_make(self, *args, **kwargs)

    def reset(self):
        """reset(head_sptr self)"""
        return _blocks_swig0.head_sptr_reset(self)

    def set_length(self, *args, **kwargs):
        """set_length(head_sptr self, uint64_t nitems)"""
        return _blocks_swig0.head_sptr_set_length(self, *args, **kwargs)

    def history(self):
        """history(head_sptr self) -> unsigned int"""
        return _blocks_swig0.head_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(head_sptr self, int which, int delay)
        declare_sample_delay(head_sptr self, unsigned int delay)
        """
        return _blocks_swig0.head_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(head_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.head_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(head_sptr self) -> double"""
        return _blocks_swig0.head_sptr_relative_rate(self)

    def start(self):
        """start(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_start(self)

    def stop(self):
        """stop(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(head_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(head_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(head_sptr self, long max_output_buffer)
        set_max_output_buffer(head_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(head_sptr self, long min_output_buffer)
        set_min_output_buffer(head_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(head_sptr self, int which) -> float
        pc_input_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(head_sptr self, int which) -> float
        pc_input_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(head_sptr self, int which) -> float
        pc_input_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(head_sptr self, int which) -> float
        pc_output_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(head_sptr self, int which) -> float
        pc_output_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(head_sptr self, int which) -> float
        pc_output_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(head_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.head_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(head_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.head_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(head_sptr self, int priority) -> int"""
        return _blocks_swig0.head_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_name(self)

    def symbol_name(self):
        """symbol_name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(head_sptr self) -> long"""
        return _blocks_swig0.head_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(head_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.head_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(head_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.head_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(head_sptr self, std::string name)"""
        return _blocks_swig0.head_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(head_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.head_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(head_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(head_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(head_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_subscribers(self, *args, **kwargs)

head_sptr_swigregister = _blocks_swig0.head_sptr_swigregister
head_sptr_swigregister(head_sptr)

head_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
head = head.make;

class message_debug_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_debug)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_debug)> self) -> message_debug_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_debug)> self, message_debug p) -> message_debug_sptr
        """
        this = _blocks_swig0.new_message_debug_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_debug_sptr self) -> message_debug"""
        return _blocks_swig0.message_debug_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_debug_sptr
    __del__ = lambda self : None;
    def make(self):
        """make(message_debug_sptr self) -> message_debug_sptr"""
        return _blocks_swig0.message_debug_sptr_make(self)

    def num_messages(self):
        """num_messages(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_num_messages(self)

    def get_message(self, *args, **kwargs):
        """get_message(message_debug_sptr self, int i) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_get_message(self, *args, **kwargs)

    def history(self):
        """history(message_debug_sptr self) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_debug_sptr self, int which, int delay)
        declare_sample_delay(message_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_debug_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_debug_sptr self) -> double"""
        return _blocks_swig0.message_debug_sptr_relative_rate(self)

    def start(self):
        """start(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_start(self)

    def stop(self):
        """stop(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(message_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(message_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_debug_sptr self, int which) -> float
        pc_input_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_debug_sptr self, int which) -> float
        pc_output_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_debug_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_debug_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_debug_sptr self, int priority) -> int"""
        return _blocks_swig0.message_debug_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_debug_sptr self) -> long"""
        return _blocks_swig0.message_debug_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_debug_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_debug_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_debug_sptr self, std::string name)"""
        return _blocks_swig0.message_debug_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_debug_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_debug_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_debug_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_subscribers(self, *args, **kwargs)

message_debug_sptr_swigregister = _blocks_swig0.message_debug_sptr_swigregister
message_debug_sptr_swigregister(message_debug_sptr)

message_debug_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_debug = message_debug.make;

class message_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_sink)> self) -> message_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_sink)> self, message_sink p) -> message_sink_sptr
        """
        this = _blocks_swig0.new_message_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_sink_sptr self) -> message_sink"""
        return _blocks_swig0.message_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args):
        """
        make(message_sink_sptr self, size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
        make(message_sink_sptr self, size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
        """
        return _blocks_swig0.message_sink_sptr_make(self, *args)

    def history(self):
        """history(message_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.message_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_sink_sptr self, int which, int delay)
        declare_sample_delay(message_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_sink_sptr self) -> double"""
        return _blocks_swig0.message_sink_sptr_relative_rate(self)

    def start(self):
        """start(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_start(self)

    def stop(self):
        """stop(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_sink_sptr self, int m)"""
        return _blocks_swig0.message_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_sink_sptr self)"""
        return _blocks_swig0.message_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_sink_sptr self, int m)"""
        return _blocks_swig0.message_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_sink_sptr self, int i) -> long"""
        return _blocks_swig0.message_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(message_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_sink_sptr self, int i) -> long"""
        return _blocks_swig0.message_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(message_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_sink_sptr self, int which) -> float
        pc_input_buffers_full(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_sink_sptr self, int which) -> float
        pc_output_buffers_full(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_sink_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_sink_sptr self)"""
        return _blocks_swig0.message_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_sink_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.message_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_sink_sptr self) -> long"""
        return _blocks_swig0.message_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_sink_sptr self, std::string name)"""
        return _blocks_swig0.message_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_subscribers(self, *args, **kwargs)

message_sink_sptr_swigregister = _blocks_swig0.message_sink_sptr_swigregister
message_sink_sptr_swigregister(message_sink_sptr)

message_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_sink = message_sink.make;

class message_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_source)> self) -> message_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_source)> self, message_source p) -> message_source_sptr
        """
        this = _blocks_swig0.new_message_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_source_sptr self) -> message_source"""
        return _blocks_swig0.message_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_source_sptr
    __del__ = lambda self : None;
    def make(self, *args):
        """
        make(message_source_sptr self, size_t itemsize, int msgq_limit=0) -> message_source_sptr
        make(message_source_sptr self, size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
        make(message_source_sptr self, size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
        """
        return _blocks_swig0.message_source_sptr_make(self, *args)

    def msgq(self):
        """msgq(message_source_sptr self) -> msg_queue_sptr"""
        return _blocks_swig0.message_source_sptr_msgq(self)

    def history(self):
        """history(message_source_sptr self) -> unsigned int"""
        return _blocks_swig0.message_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_source_sptr self, int which, int delay)
        declare_sample_delay(message_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_source_sptr self) -> double"""
        return _blocks_swig0.message_source_sptr_relative_rate(self)

    def start(self):
        """start(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_start(self)

    def stop(self):
        """stop(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_source_sptr self, int m)"""
        return _blocks_swig0.message_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_source_sptr self)"""
        return _blocks_swig0.message_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_source_sptr self, int m)"""
        return _blocks_swig0.message_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_source_sptr self, long max_output_buffer)
        set_max_output_buffer(message_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_source_sptr self, long min_output_buffer)
        set_min_output_buffer(message_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_source_sptr self, int which) -> float
        pc_input_buffers_full(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_source_sptr self, int which) -> float
        pc_input_buffers_full_var(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_source_sptr self, int which) -> float
        pc_output_buffers_full(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_source_sptr self, int which) -> float
        pc_output_buffers_full_var(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_source_sptr self)"""
        return _blocks_swig0.message_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_source_sptr self, int priority) -> int"""
        return _blocks_swig0.message_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_source_sptr self) -> long"""
        return _blocks_swig0.message_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_source_sptr self, std::string name)"""
        return _blocks_swig0.message_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_subscribers(self, *args, **kwargs)

message_source_sptr_swigregister = _blocks_swig0.message_source_sptr_swigregister
message_source_sptr_swigregister(message_source_sptr)

message_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_source = message_source.make;

class message_strobe_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_strobe)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_strobe)> self) -> message_strobe_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_strobe)> self, message_strobe p) -> message_strobe_sptr
        """
        this = _blocks_swig0.new_message_strobe_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_strobe_sptr self) -> message_strobe"""
        return _blocks_swig0.message_strobe_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(message_strobe_sptr self, swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_sptr_make(self, *args, **kwargs)

    def set_msg(self, *args, **kwargs):
        """set_msg(message_strobe_sptr self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr_set_msg(self, *args, **kwargs)

    def msg(self):
        """msg(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_msg(self)

    def set_period(self, *args, **kwargs):
        """set_period(message_strobe_sptr self, float period_ms)"""
        return _blocks_swig0.message_strobe_sptr_set_period(self, *args, **kwargs)

    def period(self):
        """period(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_period(self)

    def history(self):
        """history(message_strobe_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_strobe_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_strobe_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_strobe_sptr self) -> double"""
        return _blocks_swig0.message_strobe_sptr_relative_rate(self)

    def start(self):
        """start(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_start(self)

    def stop(self):
        """stop(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_strobe_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_strobe_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_strobe_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_strobe_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_strobe_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_strobe_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_strobe_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_strobe_sptr self) -> long"""
        return _blocks_swig0.message_strobe_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_strobe_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_strobe_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_strobe_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_strobe_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_strobe_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_subscribers(self, *args, **kwargs)

message_strobe_sptr_swigregister = _blocks_swig0.message_strobe_sptr_swigregister
message_strobe_sptr_swigregister(message_strobe_sptr)

message_strobe_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_strobe = message_strobe.make;

class message_strobe_random_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_strobe_random)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_strobe_random)> self) -> message_strobe_random_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_strobe_random)> self, message_strobe_random p) -> message_strobe_random_sptr
        """
        this = _blocks_swig0.new_message_strobe_random_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_strobe_random_sptr self) -> message_strobe_random"""
        return _blocks_swig0.message_strobe_random_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """
        make(message_strobe_random_sptr self, swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, 
            float std_ms) -> message_strobe_random_sptr
        """
        return _blocks_swig0.message_strobe_random_sptr_make(self, *args, **kwargs)

    def set_msg(self, *args, **kwargs):
        """set_msg(message_strobe_random_sptr self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr_set_msg(self, *args, **kwargs)

    def msg(self):
        """msg(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_msg(self)

    def set_dist(self, *args, **kwargs):
        """set_dist(message_strobe_random_sptr self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_sptr_set_dist(self, *args, **kwargs)

    def dist(self):
        """dist(message_strobe_random_sptr self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_sptr_dist(self)

    def set_mean(self, *args, **kwargs):
        """set_mean(message_strobe_random_sptr self, float mean)"""
        return _blocks_swig0.message_strobe_random_sptr_set_mean(self, *args, **kwargs)

    def mean(self):
        """mean(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_mean(self)

    def set_std(self, *args, **kwargs):
        """set_std(message_strobe_random_sptr self, float std)"""
        return _blocks_swig0.message_strobe_random_sptr_set_std(self, *args, **kwargs)

    def std(self):
        """std(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_std(self)

    def history(self):
        """history(message_strobe_random_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_strobe_random_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_random_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_random_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_strobe_random_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_strobe_random_sptr self) -> double"""
        return _blocks_swig0.message_strobe_random_sptr_relative_rate(self)

    def start(self):
        """start(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_start(self)

    def stop(self):
        """stop(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_strobe_random_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_strobe_random_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_strobe_random_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_random_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_strobe_random_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_random_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_strobe_random_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_random_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_strobe_random_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_random_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_strobe_random_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_strobe_random_sptr self) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_strobe_random_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_strobe_random_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_strobe_random_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_random_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_strobe_random_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_strobe_random_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_subscribers(self, *args, **kwargs)

message_strobe_random_sptr_swigregister = _blocks_swig0.message_strobe_random_sptr_swigregister
message_strobe_random_sptr_swigregister(message_strobe_random_sptr)

message_strobe_random_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_strobe_random = message_strobe_random.make;

class message_burst_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_burst_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::message_burst_source)> self) -> message_burst_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_burst_source)> self, message_burst_source p) -> message_burst_source_sptr
        """
        this = _blocks_swig0.new_message_burst_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(message_burst_source_sptr self) -> message_burst_source"""
        return _blocks_swig0.message_burst_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_burst_source_sptr
    __del__ = lambda self : None;
    def make(self, *args):
        """
        make(message_burst_source_sptr self, size_t itemsize, int msgq_limit) -> message_burst_source_sptr
        make(message_burst_source_sptr self, size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
        """
        return _blocks_swig0.message_burst_source_sptr_make(self, *args)

    def msgq(self):
        """msgq(message_burst_source_sptr self) -> msg_queue_sptr"""
        return _blocks_swig0.message_burst_source_sptr_msgq(self)

    def history(self):
        """history(message_burst_source_sptr self) -> unsigned int"""
        return _blocks_swig0.message_burst_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_burst_source_sptr self, int which, int delay)
        declare_sample_delay(message_burst_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_burst_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(message_burst_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_burst_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(message_burst_source_sptr self) -> double"""
        return _blocks_swig0.message_burst_source_sptr_relative_rate(self)

    def start(self):
        """start(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_start(self)

    def stop(self):
        """stop(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(message_burst_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_burst_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(message_burst_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_burst_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(message_burst_source_sptr self, int m)"""
        return _blocks_swig0.message_burst_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_burst_source_sptr self)"""
        return _blocks_swig0.message_burst_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(message_burst_source_sptr self, int m)"""
        return _blocks_swig0.message_burst_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(message_burst_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_burst_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_burst_source_sptr self, long max_output_buffer)
        set_max_output_buffer(message_burst_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_burst_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(message_burst_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_burst_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_burst_source_sptr self, long min_output_buffer)
        set_min_output_buffer(message_burst_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_burst_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full_var(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full_var(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(message_burst_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_burst_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(message_burst_source_sptr self)"""
        return _blocks_swig0.message_burst_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(message_burst_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_burst_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(message_burst_source_sptr self, int priority) -> int"""
        return _blocks_swig0.message_burst_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(message_burst_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_burst_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(message_burst_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_burst_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(message_burst_source_sptr self) -> long"""
        return _blocks_swig0.message_burst_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(message_burst_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_burst_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(message_burst_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(message_burst_source_sptr self, std::string name)"""
        return _blocks_swig0.message_burst_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(message_burst_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_burst_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(message_burst_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(message_burst_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(message_burst_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_subscribers(self, *args, **kwargs)

message_burst_source_sptr_swigregister = _blocks_swig0.message_burst_source_sptr_swigregister
message_burst_source_sptr_swigregister(message_burst_source_sptr)

message_burst_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
message_burst_source = message_burst_source.make;

class nop_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::nop)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::nop)> self) -> nop_sptr
        __init__(boost::shared_ptr<(gr::blocks::nop)> self, nop p) -> nop_sptr
        """
        this = _blocks_swig0.new_nop_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(nop_sptr self) -> nop"""
        return _blocks_swig0.nop_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_nop_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(nop_sptr self, size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_sptr_make(self, *args, **kwargs)

    def nmsgs_received(self):
        """nmsgs_received(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_nmsgs_received(self)

    def ctrlport_test(self):
        """ctrlport_test(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_ctrlport_test(self)

    def set_ctrlport_test(self, *args, **kwargs):
        """set_ctrlport_test(nop_sptr self, int x)"""
        return _blocks_swig0.nop_sptr_set_ctrlport_test(self, *args, **kwargs)

    def history(self):
        """history(nop_sptr self) -> unsigned int"""
        return _blocks_swig0.nop_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(nop_sptr self, int which, int delay)
        declare_sample_delay(nop_sptr self, unsigned int delay)
        """
        return _blocks_swig0.nop_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(nop_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.nop_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(nop_sptr self) -> double"""
        return _blocks_swig0.nop_sptr_relative_rate(self)

    def start(self):
        """start(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_start(self)

    def stop(self):
        """stop(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(nop_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(nop_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(nop_sptr self, long max_output_buffer)
        set_max_output_buffer(nop_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(nop_sptr self, long min_output_buffer)
        set_min_output_buffer(nop_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(nop_sptr self, int which) -> float
        pc_input_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(nop_sptr self, int which) -> float
        pc_input_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(nop_sptr self, int which) -> float
        pc_input_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(nop_sptr self, int which) -> float
        pc_output_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(nop_sptr self, int which) -> float
        pc_output_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(nop_sptr self, int which) -> float
        pc_output_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(nop_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.nop_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(nop_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.nop_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(nop_sptr self, int priority) -> int"""
        return _blocks_swig0.nop_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_name(self)

    def symbol_name(self):
        """symbol_name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(nop_sptr self) -> long"""
        return _blocks_swig0.nop_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(nop_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.nop_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(nop_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.nop_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(nop_sptr self, std::string name)"""
        return _blocks_swig0.nop_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(nop_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.nop_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(nop_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(nop_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(nop_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_subscribers(self, *args, **kwargs)

nop_sptr_swigregister = _blocks_swig0.nop_sptr_swigregister
nop_sptr_swigregister(nop_sptr)

nop_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
nop = nop.make;

class null_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::null_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::null_sink)> self) -> null_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::null_sink)> self, null_sink p) -> null_sink_sptr
        """
        this = _blocks_swig0.new_null_sink_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(null_sink_sptr self) -> null_sink"""
        return _blocks_swig0.null_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_null_sink_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(null_sink_sptr self, size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_sptr_make(self, *args, **kwargs)

    def history(self):
        """history(null_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(null_sink_sptr self, int which, int delay)
        declare_sample_delay(null_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(null_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(null_sink_sptr self) -> double"""
        return _blocks_swig0.null_sink_sptr_relative_rate(self)

    def start(self):
        """start(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_start(self)

    def stop(self):
        """stop(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(null_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(null_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(null_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(null_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(null_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(null_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(null_sink_sptr self, int which) -> float
        pc_input_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(null_sink_sptr self, int which) -> float
        pc_output_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(null_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_sink_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(null_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_sink_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(null_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.null_sink_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_name(self)

    def symbol_name(self):
        """symbol_name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(null_sink_sptr self) -> long"""
        return _blocks_swig0.null_sink_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(null_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_sink_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(null_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_sink_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(null_sink_sptr self, std::string name)"""
        return _blocks_swig0.null_sink_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(null_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.null_sink_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(null_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(null_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(null_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_subscribers(self, *args, **kwargs)

null_sink_sptr_swigregister = _blocks_swig0.null_sink_sptr_swigregister
null_sink_sptr_swigregister(null_sink_sptr)

null_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
null_sink = null_sink.make;

class null_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::null_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(boost::shared_ptr<(gr::blocks::null_source)> self) -> null_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::null_source)> self, null_source p) -> null_source_sptr
        """
        this = _blocks_swig0.new_null_source_sptr(*args)
        try: self.this.append(this)
        except: self.this = this
    def __deref__(self):
        """__deref__(null_source_sptr self) -> null_source"""
        return _blocks_swig0.null_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_null_source_sptr
    __del__ = lambda self : None;
    def make(self, *args, **kwargs):
        """make(null_source_sptr self, size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_sptr_make(self, *args, **kwargs)

    def history(self):
        """history(null_source_sptr self) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_history(self)

    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(null_source_sptr self, int which, int delay)
        declare_sample_delay(null_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, *args, **kwargs):
        """sample_delay(null_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_sample_delay(self, *args, **kwargs)

    def output_multiple(self):
        """output_multiple(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_output_multiple(self)

    def relative_rate(self):
        """relative_rate(null_source_sptr self) -> double"""
        return _blocks_swig0.null_source_sptr_relative_rate(self)

    def start(self):
        """start(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_start(self)

    def stop(self):
        """stop(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_stop(self)

    def nitems_read(self, *args, **kwargs):
        """nitems_read(null_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_read(self, *args, **kwargs)

    def nitems_written(self, *args, **kwargs):
        """nitems_written(null_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_written(self, *args, **kwargs)

    def max_noutput_items(self):
        """max_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, *args, **kwargs):
        """set_max_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_max_noutput_items(self, *args, **kwargs)

    def unset_max_noutput_items(self):
        """unset_max_noutput_items(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, *args, **kwargs):
        """set_min_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_min_noutput_items(self, *args, **kwargs)

    def min_noutput_items(self):
        """min_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, *args, **kwargs):
        """max_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_max_output_buffer(self, *args, **kwargs)

    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(null_source_sptr self, long max_output_buffer)
        set_max_output_buffer(null_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, *args, **kwargs):
        """min_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_min_output_buffer(self, *args, **kwargs)

    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(null_source_sptr self, long min_output_buffer)
        set_min_output_buffer(null_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self):
        """pc_noutput_items(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self):
        """pc_noutput_items_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self):
        """pc_nproduced(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self):
        """pc_nproduced_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self):
        """pc_nproduced_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(null_source_sptr self, int which) -> float
        pc_input_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(null_source_sptr self, int which) -> float
        pc_input_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(null_source_sptr self, int which) -> float
        pc_output_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(null_source_sptr self, int which) -> float
        pc_output_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self):
        """pc_work_time(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self):
        """pc_work_time_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self):
        """pc_work_time_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self):
        """pc_work_time_total(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self):
        """pc_throughput_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, *args, **kwargs):
        """set_processor_affinity(null_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_source_sptr_set_processor_affinity(self, *args, **kwargs)

    def unset_processor_affinity(self):
        """unset_processor_affinity(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self):
        """processor_affinity(null_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_source_sptr_processor_affinity(self)

    def active_thread_priority(self):
        """active_thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_active_thread_priority(self)

    def thread_priority(self):
        """thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_thread_priority(self)

    def set_thread_priority(self, *args, **kwargs):
        """set_thread_priority(null_source_sptr self, int priority) -> int"""
        return _blocks_swig0.null_source_sptr_set_thread_priority(self, *args, **kwargs)

    def name(self):
        """name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_name(self)

    def symbol_name(self):
        """symbol_name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_symbol_name(self)

    def input_signature(self):
        """input_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_input_signature(self)

    def output_signature(self):
        """output_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_output_signature(self)

    def unique_id(self):
        """unique_id(null_source_sptr self) -> long"""
        return _blocks_swig0.null_source_sptr_unique_id(self)

    def to_basic_block(self):
        """to_basic_block(null_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_source_sptr_to_basic_block(self)

    def check_topology(self, *args, **kwargs):
        """check_topology(null_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_source_sptr_check_topology(self, *args, **kwargs)

    def alias(self):
        """alias(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_alias(self)

    def set_block_alias(self, *args, **kwargs):
        """set_block_alias(null_source_sptr self, std::string name)"""
        return _blocks_swig0.null_source_sptr_set_block_alias(self, *args, **kwargs)

    def _post(self, *args, **kwargs):
        """_post(null_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.null_source_sptr__post(self, *args, **kwargs)

    def message_ports_in(self):
        """message_ports_in(null_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_in(self)

    def message_ports_out(self):
        """message_ports_out(null_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_out(self)

    def message_subscribers(self, *args, **kwargs):
        """message_subscribers(null_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_subscribers(self, *args, **kwargs)

null_source_sptr_swigregister = _blocks_swig0.null_source_sptr_swigregister
null_source_sptr_swigregister(null_source_sptr)

null_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
null_source = null_source.make;



