# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.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 as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_baz_swig')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_baz_swig')
    _baz_swig = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_baz_swig', [dirname(__file__)])
        except ImportError:
            import _baz_swig
            return _baz_swig
        try:
            _mod = imp.load_module('_baz_swig', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _baz_swig = swig_import_helper()
    del swig_import_helper
else:
    import _baz_swig
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        object.__setattr__(self, 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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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



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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _baz_swig.high_res_timer_epoch()
IN_GR_BAZ = _baz_swig.IN_GR_BAZ
GR_BAZ_WITH_CMAKE = _baz_swig.GR_BAZ_WITH_CMAKE
HAVE_NETDB_H = _baz_swig.HAVE_NETDB_H
HAVE_SYS_TYPES_H = _baz_swig.HAVE_SYS_TYPES_H
HAVE_SYS_SOCKET_H = _baz_swig.HAVE_SYS_SOCKET_H
HAVE_NETINET_IN_H = _baz_swig.HAVE_NETINET_IN_H
HAVE_ARPA_INET_H = _baz_swig.HAVE_ARPA_INET_H
HAVE_XTIME = _baz_swig.HAVE_XTIME
UHD_FOUND = _baz_swig.UHD_FOUND
LIBUSB_FOUND = _baz_swig.LIBUSB_FOUND
ARMADILLO_FOUND = _baz_swig.ARMADILLO_FOUND
SDL_FOUND = _baz_swig.SDL_FOUND
class baz_rtl_source_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_rtl_source_c)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_rtl_source_c)> self) -> baz_rtl_source_c_sptr
        __init__(boost::shared_ptr<(baz_rtl_source_c)> self, baz_rtl_source_c * p) -> baz_rtl_source_c_sptr
        """
        this = _baz_swig.new_baz_rtl_source_c_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_rtl_source_c_sptr self) -> baz_rtl_source_c *"""
        return _baz_swig.baz_rtl_source_c_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_rtl_source_c_sptr
    __del__ = lambda self: None

    def set_defaults(self):
        """
        set_defaults(baz_rtl_source_c_sptr self)



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_defaults(self)


    def set_output_format(self, size):
        """
        set_output_format(baz_rtl_source_c_sptr self, int size) -> bool



        Params: (size)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_output_format(self, size)


    def set_status_msgq(self, queue):
        """
        set_status_msgq(baz_rtl_source_c_sptr self, msg_queue_sptr queue)



        Params: (queue)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_status_msgq(self, queue)


    def create(self, reset_defaults=False):
        """
        create(baz_rtl_source_c_sptr self, bool reset_defaults=False) -> bool



        Params: (reset_defaults)
        """
        return _baz_swig.baz_rtl_source_c_sptr_create(self, reset_defaults)


    def destroy(self):
        """
        destroy(baz_rtl_source_c_sptr self)



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_destroy(self)


    def set_vid(self, vid):
        """
        set_vid(baz_rtl_source_c_sptr self, int vid)



        Params: (vid)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_vid(self, vid)


    def set_pid(self, pid):
        """
        set_pid(baz_rtl_source_c_sptr self, int pid)



        Params: (pid)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_pid(self, pid)


    def set_default_timeout(self, timeout):
        """
        set_default_timeout(baz_rtl_source_c_sptr self, int timeout)



        Params: (timeout)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_default_timeout(self, timeout)


    def set_fir_coefficients(self, coeffs):
        """
        set_fir_coefficients(baz_rtl_source_c_sptr self, std::vector< int,std::allocator< int > > const & coeffs)



        Params: (coeffs)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_fir_coefficients(self, coeffs)


    def set_crystal_frequency(self, freq):
        """
        set_crystal_frequency(baz_rtl_source_c_sptr self, int freq)



        Params: (freq)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_crystal_frequency(self, freq)


    def set_tuner_name(self, name):
        """
        set_tuner_name(baz_rtl_source_c_sptr self, char const * name)



        Params: (name)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_tuner_name(self, name)


    def recv_samples_per_packet(self):
        """
        recv_samples_per_packet(baz_rtl_source_c_sptr self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_recv_samples_per_packet(self)


    def samples_received(self):
        """
        samples_received(baz_rtl_source_c_sptr self) -> uint64_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_samples_received(self)


    def overflows(self):
        """
        overflows(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_overflows(self)


    def running(self):
        """
        running(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_running(self)


    def buffer_size(self):
        """
        buffer_size(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_size(self)


    def buffer_times(self):
        """
        buffer_times(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_times(self)


    def buffering(self):
        """
        buffering(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffering(self)


    def read_packet_count(self):
        """
        read_packet_count(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_read_packet_count(self)


    def buffer_overflow_count(self):
        """
        buffer_overflow_count(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_overflow_count(self)


    def buffer_underrun_count(self):
        """
        buffer_underrun_count(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_underrun_count(self)


    def set_verbose(self, on=True):
        """
        set_verbose(baz_rtl_source_c_sptr self, bool on=True)



        Params: (on)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_verbose(self, on)


    def set_read_length(self, length):
        """
        set_read_length(baz_rtl_source_c_sptr self, int length)



        Params: (length)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_read_length(self, length)


    def set_buffer_multiplier(self, mul):
        """
        set_buffer_multiplier(baz_rtl_source_c_sptr self, int mul)



        Params: (mul)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_buffer_multiplier(self, mul)


    def set_use_buffer(self, use=True):
        """
        set_use_buffer(baz_rtl_source_c_sptr self, bool use=True)



        Params: (use)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_use_buffer(self, use)


    def set_buffer_level(self, level):
        """
        set_buffer_level(baz_rtl_source_c_sptr self, float level)



        Params: (level)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_buffer_level(self, level)


    def relative_gain(self):
        """
        relative_gain(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_relative_gain(self)


    def verbose(self):
        """
        verbose(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_verbose(self)


    def read_length(self):
        """
        read_length(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_read_length(self)


    def buffer_multiplier(self):
        """
        buffer_multiplier(baz_rtl_source_c_sptr self) -> uint32_t



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_multiplier(self)


    def use_buffer(self):
        """
        use_buffer(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_use_buffer(self)


    def buffer_level(self):
        """
        buffer_level(baz_rtl_source_c_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_buffer_level(self)


    def set_sample_rate(self, sample_rate):
        """
        set_sample_rate(baz_rtl_source_c_sptr self, double sample_rate) -> bool



        Params: (sample_rate)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_sample_rate(self, sample_rate)


    def set_frequency(self, freq):
        """
        set_frequency(baz_rtl_source_c_sptr self, double freq) -> bool



        Params: (freq)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_frequency(self, freq)


    def set_gain(self, gain):
        """
        set_gain(baz_rtl_source_c_sptr self, double gain) -> bool



        Params: (gain)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_gain(self, gain)


    def set_bandwidth(self, bandwidth):
        """
        set_bandwidth(baz_rtl_source_c_sptr self, double bandwidth) -> bool



        Params: (bandwidth)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_bandwidth(self, bandwidth)


    def set_gain_mode(self, *args):
        """
        set_gain_mode(baz_rtl_source_c_sptr self, int mode) -> bool
        set_gain_mode(baz_rtl_source_c_sptr self, char const * mode) -> bool



        Params: (mode)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_gain_mode(self, *args)


    def set_relative_gain(self, on=True):
        """
        set_relative_gain(baz_rtl_source_c_sptr self, bool on=True)



        Params: (on)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_relative_gain(self, on)


    def set_auto_gain_mode(self, on=True):
        """
        set_auto_gain_mode(baz_rtl_source_c_sptr self, bool on=True) -> int



        Params: (on)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_auto_gain_mode(self, on)


    def name(self):
        """
        name(baz_rtl_source_c_sptr self) -> char const *



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_name(self)


    def sample_rate(self):
        """
        sample_rate(baz_rtl_source_c_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_sample_rate(self)


    def sample_rate_range(self):
        """
        sample_rate_range(baz_rtl_source_c_sptr self) -> std::pair< double,double >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_sample_rate_range(self)


    def frequency(self):
        """
        frequency(baz_rtl_source_c_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_frequency(self)


    def gain(self):
        """
        gain(baz_rtl_source_c_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain(self)


    def bandwidth(self):
        """
        bandwidth(baz_rtl_source_c_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_bandwidth(self)


    def gain_mode(self):
        """
        gain_mode(baz_rtl_source_c_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain_mode(self)


    def gain_mode_string(self):
        """
        gain_mode_string(baz_rtl_source_c_sptr self) -> std::string



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain_mode_string(self)


    def auto_gain_mode(self):
        """
        auto_gain_mode(baz_rtl_source_c_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_auto_gain_mode(self)


    def gain_range(self):
        """
        gain_range(baz_rtl_source_c_sptr self) -> std::pair< double,double >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain_range(self)


    def gain_values(self):
        """
        gain_values(baz_rtl_source_c_sptr self) -> pmt_vector_double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain_values(self)


    def frequency_range(self):
        """
        frequency_range(baz_rtl_source_c_sptr self) -> std::pair< double,double >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_frequency_range(self)


    def bandwidth_range(self):
        """
        bandwidth_range(baz_rtl_source_c_sptr self) -> std::pair< double,double >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_bandwidth_range(self)


    def bandwidth_values(self):
        """
        bandwidth_values(baz_rtl_source_c_sptr self) -> pmt_vector_double



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_bandwidth_values(self)


    def gain_modes(self):
        """
        gain_modes(baz_rtl_source_c_sptr self) -> std::map< int,std::string,std::less< int >,std::allocator< std::pair< int const,std::string > > >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_gain_modes(self)


    def calc_appropriate_gain_mode(self):
        """
        calc_appropriate_gain_mode(baz_rtl_source_c_sptr self) -> std::pair< bool,int >



        Params: (NONE)
        """
        return _baz_swig.baz_rtl_source_c_sptr_calc_appropriate_gain_mode(self)


    def history(self):
        """history(baz_rtl_source_c_sptr self) -> unsigned int"""
        return _baz_swig.baz_rtl_source_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_rtl_source_c_sptr self, int which, int delay)
        declare_sample_delay(baz_rtl_source_c_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_rtl_source_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_rtl_source_c_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_rtl_source_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_rtl_source_c_sptr self) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_rtl_source_c_sptr self) -> double"""
        return _baz_swig.baz_rtl_source_c_sptr_relative_rate(self)


    def start(self):
        """start(baz_rtl_source_c_sptr self) -> bool"""
        return _baz_swig.baz_rtl_source_c_sptr_start(self)


    def stop(self):
        """stop(baz_rtl_source_c_sptr self) -> bool"""
        return _baz_swig.baz_rtl_source_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_rtl_source_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_rtl_source_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_rtl_source_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_rtl_source_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_rtl_source_c_sptr self) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_rtl_source_c_sptr self, int m)"""
        return _baz_swig.baz_rtl_source_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_rtl_source_c_sptr self)"""
        return _baz_swig.baz_rtl_source_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_rtl_source_c_sptr self) -> bool"""
        return _baz_swig.baz_rtl_source_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_rtl_source_c_sptr self, int m)"""
        return _baz_swig.baz_rtl_source_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_rtl_source_c_sptr self) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_rtl_source_c_sptr self, int i) -> long"""
        return _baz_swig.baz_rtl_source_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_rtl_source_c_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_rtl_source_c_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_rtl_source_c_sptr self, int i) -> long"""
        return _baz_swig.baz_rtl_source_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_rtl_source_c_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_rtl_source_c_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_rtl_source_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_rtl_source_c_sptr self, int which) -> float
        pc_input_buffers_full(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_rtl_source_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_rtl_source_c_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_rtl_source_c_sptr self, int which) -> float
        pc_output_buffers_full(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_rtl_source_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_rtl_source_c_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_rtl_source_c_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_rtl_source_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_rtl_source_c_sptr self) -> float"""
        return _baz_swig.baz_rtl_source_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_rtl_source_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_rtl_source_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_rtl_source_c_sptr self)"""
        return _baz_swig.baz_rtl_source_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_rtl_source_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_rtl_source_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_rtl_source_c_sptr self) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_rtl_source_c_sptr self) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_rtl_source_c_sptr self, int priority) -> int"""
        return _baz_swig.baz_rtl_source_c_sptr_set_thread_priority(self, priority)


    def symbol_name(self):
        """symbol_name(baz_rtl_source_c_sptr self) -> std::string"""
        return _baz_swig.baz_rtl_source_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_rtl_source_c_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_rtl_source_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_rtl_source_c_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_rtl_source_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_rtl_source_c_sptr self) -> long"""
        return _baz_swig.baz_rtl_source_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_rtl_source_c_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_rtl_source_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_rtl_source_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_rtl_source_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_rtl_source_c_sptr self) -> std::string"""
        return _baz_swig.baz_rtl_source_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_rtl_source_c_sptr self, std::string name)"""
        return _baz_swig.baz_rtl_source_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_rtl_source_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_rtl_source_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_rtl_source_c_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_rtl_source_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_rtl_source_c_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_rtl_source_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_rtl_source_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_rtl_source_c_sptr_message_subscribers(self, which_port)

baz_rtl_source_c_sptr_swigregister = _baz_swig.baz_rtl_source_c_sptr_swigregister
baz_rtl_source_c_sptr_swigregister(baz_rtl_source_c_sptr)


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


def rtl_source_c(defer_creation=False, output_size=0):
    """
    rtl_source_c(bool defer_creation=False, int output_size=0) -> baz_rtl_source_c_sptr

    capture samples from an RTL2832-based device.

    Return a shared_ptr to a new instance of baz_rtl_source_c.

    Params: (defer_creation, output_size)
    """
    return _baz_swig.rtl_source_c(defer_creation, output_size)
class baz_print_char_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_print_char)> class."""

    thisown = _swig_property(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<(baz_print_char)> self) -> baz_print_char_sptr
        __init__(boost::shared_ptr<(baz_print_char)> self, baz_print_char * p) -> baz_print_char_sptr
        """
        this = _baz_swig.new_baz_print_char_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_print_char_sptr self) -> baz_print_char *"""
        return _baz_swig.baz_print_char_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_print_char_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_print_char_sptr self) -> unsigned int"""
        return _baz_swig.baz_print_char_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_print_char_sptr self, int which, int delay)
        declare_sample_delay(baz_print_char_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_print_char_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_print_char_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_print_char_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_print_char_sptr self) -> int"""
        return _baz_swig.baz_print_char_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_print_char_sptr self) -> double"""
        return _baz_swig.baz_print_char_sptr_relative_rate(self)


    def start(self):
        """start(baz_print_char_sptr self) -> bool"""
        return _baz_swig.baz_print_char_sptr_start(self)


    def stop(self):
        """stop(baz_print_char_sptr self) -> bool"""
        return _baz_swig.baz_print_char_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_print_char_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_print_char_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_print_char_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_print_char_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_print_char_sptr self) -> int"""
        return _baz_swig.baz_print_char_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_print_char_sptr self, int m)"""
        return _baz_swig.baz_print_char_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_print_char_sptr self)"""
        return _baz_swig.baz_print_char_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_print_char_sptr self) -> bool"""
        return _baz_swig.baz_print_char_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_print_char_sptr self, int m)"""
        return _baz_swig.baz_print_char_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_print_char_sptr self) -> int"""
        return _baz_swig.baz_print_char_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_print_char_sptr self, int i) -> long"""
        return _baz_swig.baz_print_char_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_print_char_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_print_char_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_print_char_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_print_char_sptr self, int i) -> long"""
        return _baz_swig.baz_print_char_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_print_char_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_print_char_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_print_char_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_print_char_sptr self, int which) -> float
        pc_input_buffers_full(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_print_char_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_print_char_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_print_char_sptr self, int which) -> float
        pc_output_buffers_full(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_print_char_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_print_char_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_print_char_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_print_char_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_print_char_sptr self) -> float"""
        return _baz_swig.baz_print_char_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_print_char_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_print_char_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_print_char_sptr self)"""
        return _baz_swig.baz_print_char_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_print_char_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_print_char_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_print_char_sptr self) -> int"""
        return _baz_swig.baz_print_char_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_print_char_sptr self) -> int"""
        return _baz_swig.baz_print_char_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_print_char_sptr self, int priority) -> int"""
        return _baz_swig.baz_print_char_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_print_char_sptr self) -> std::string"""
        return _baz_swig.baz_print_char_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_print_char_sptr self) -> std::string"""
        return _baz_swig.baz_print_char_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_print_char_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_print_char_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_print_char_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_print_char_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_print_char_sptr self) -> long"""
        return _baz_swig.baz_print_char_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_print_char_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_print_char_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_print_char_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_print_char_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_print_char_sptr self) -> std::string"""
        return _baz_swig.baz_print_char_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_print_char_sptr self, std::string name)"""
        return _baz_swig.baz_print_char_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_print_char_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_print_char_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_print_char_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_print_char_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_print_char_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_print_char_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_print_char_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_print_char_sptr_message_subscribers(self, which_port)

baz_print_char_sptr_swigregister = _baz_swig.baz_print_char_sptr_swigregister
baz_print_char_sptr_swigregister(baz_print_char_sptr)


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


def print_char(threshold=0.0, limit=-1, file=None, padding=1, fixed_limit=False, append=False):
    """
    print_char(float threshold=0.0, int limit=-1, char const * file=None, int padding=1, bool fixed_limit=False, bool append=False) -> baz_print_char_sptr

    square a stream of floats.

    Return a shared_ptr to a new instance of baz_print_char.

    To avoid accidental use of raw pointers, baz_print_char's constructor is private. howto_make_square_ff is the public interface for creating new instances.

    Params: (threshold, limit, file, padding, fixed_limit, append)
    """
    return _baz_swig.print_char(threshold, limit, file, padding, fixed_limit, append)
class baz_unpacked_to_packed_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_unpacked_to_packed_bb)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_unpacked_to_packed_bb)> self) -> baz_unpacked_to_packed_bb_sptr
        __init__(boost::shared_ptr<(baz_unpacked_to_packed_bb)> self, baz_unpacked_to_packed_bb * p) -> baz_unpacked_to_packed_bb_sptr
        """
        this = _baz_swig.new_baz_unpacked_to_packed_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_unpacked_to_packed_bb_sptr self) -> baz_unpacked_to_packed_bb *"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_unpacked_to_packed_bb_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_unpacked_to_packed_bb_sptr self) -> unsigned int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_unpacked_to_packed_bb_sptr self, int which, int delay)
        declare_sample_delay(baz_unpacked_to_packed_bb_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_unpacked_to_packed_bb_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_unpacked_to_packed_bb_sptr self) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_unpacked_to_packed_bb_sptr self) -> double"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_relative_rate(self)


    def start(self):
        """start(baz_unpacked_to_packed_bb_sptr self) -> bool"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_start(self)


    def stop(self):
        """stop(baz_unpacked_to_packed_bb_sptr self) -> bool"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_unpacked_to_packed_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_unpacked_to_packed_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_unpacked_to_packed_bb_sptr self) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_unpacked_to_packed_bb_sptr self, int m)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_unpacked_to_packed_bb_sptr self)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_unpacked_to_packed_bb_sptr self) -> bool"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_unpacked_to_packed_bb_sptr self, int m)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_unpacked_to_packed_bb_sptr self) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_unpacked_to_packed_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_unpacked_to_packed_bb_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_unpacked_to_packed_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_unpacked_to_packed_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_unpacked_to_packed_bb_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_unpacked_to_packed_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_unpacked_to_packed_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_unpacked_to_packed_bb_sptr self) -> float"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_unpacked_to_packed_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_unpacked_to_packed_bb_sptr self)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_unpacked_to_packed_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_unpacked_to_packed_bb_sptr self) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_unpacked_to_packed_bb_sptr self) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_unpacked_to_packed_bb_sptr self, int priority) -> int"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_unpacked_to_packed_bb_sptr self) -> std::string"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_unpacked_to_packed_bb_sptr self) -> std::string"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_unpacked_to_packed_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_unpacked_to_packed_bb_sptr self) -> long"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_unpacked_to_packed_bb_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_unpacked_to_packed_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_unpacked_to_packed_bb_sptr self) -> std::string"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_unpacked_to_packed_bb_sptr self, std::string name)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_unpacked_to_packed_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_unpacked_to_packed_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_unpacked_to_packed_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_unpacked_to_packed_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_unpacked_to_packed_bb_sptr_message_subscribers(self, which_port)

baz_unpacked_to_packed_bb_sptr_swigregister = _baz_swig.baz_unpacked_to_packed_bb_sptr_swigregister
baz_unpacked_to_packed_bb_sptr_swigregister(baz_unpacked_to_packed_bb_sptr)


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


def unpacked_to_packed_bb(*args, **kwargs):
    """
    unpacked_to_packed_bb(unsigned int bits_per_chunk, unsigned int bits_into_output, int endianness) -> baz_unpacked_to_packed_bb_sptr

    Convert a stream of unpacked bytes or shorts into a stream of packed bytes or shorts.

    input: stream of unsigned char; output: stream of unsigned char


    This is the inverse of gr_packed_to_unpacked_XX.


    The low  bits are extracted from each input byte or short. These bits are then packed densely into the output bytes or shorts, such that all 8 or 16 bits of the output bytes or shorts are filled with valid input bits. The right thing is done if bits_per_chunk is not a power of two.


    The combination of gr_packed_to_unpacked_XX followed by gr_chunks_to_symbols_Xf or gr_chunks_to_symbols_Xc handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.

    Params: (bits_per_chunk, bits_into_output, endianness)
    """
    return _baz_swig.unpacked_to_packed_bb(*args, **kwargs)
class baz_pow_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_pow_cc)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_pow_cc)> self) -> baz_pow_cc_sptr
        __init__(boost::shared_ptr<(baz_pow_cc)> self, baz_pow_cc * p) -> baz_pow_cc_sptr
        """
        this = _baz_swig.new_baz_pow_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_pow_cc_sptr self) -> baz_pow_cc *"""
        return _baz_swig.baz_pow_cc_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_pow_cc_sptr
    __del__ = lambda self: None

    def set_exponent(self, exponent):
        """
        set_exponent(baz_pow_cc_sptr self, float exponent)



        Params: (exponent)
        """
        return _baz_swig.baz_pow_cc_sptr_set_exponent(self, exponent)


    def set_division_exponent(self, div_exp):
        """
        set_division_exponent(baz_pow_cc_sptr self, float div_exp)



        Params: (div_exp)
        """
        return _baz_swig.baz_pow_cc_sptr_set_division_exponent(self, div_exp)


    def exponent(self):
        """
        exponent(baz_pow_cc_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_pow_cc_sptr_exponent(self)


    def division_exponent(self):
        """
        division_exponent(baz_pow_cc_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_pow_cc_sptr_division_exponent(self)


    def history(self):
        """history(baz_pow_cc_sptr self) -> unsigned int"""
        return _baz_swig.baz_pow_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_pow_cc_sptr self, int which, int delay)
        declare_sample_delay(baz_pow_cc_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_pow_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_pow_cc_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_pow_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_pow_cc_sptr self) -> int"""
        return _baz_swig.baz_pow_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_pow_cc_sptr self) -> double"""
        return _baz_swig.baz_pow_cc_sptr_relative_rate(self)


    def start(self):
        """start(baz_pow_cc_sptr self) -> bool"""
        return _baz_swig.baz_pow_cc_sptr_start(self)


    def stop(self):
        """stop(baz_pow_cc_sptr self) -> bool"""
        return _baz_swig.baz_pow_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_pow_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_pow_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_pow_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_pow_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_pow_cc_sptr self) -> int"""
        return _baz_swig.baz_pow_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_pow_cc_sptr self, int m)"""
        return _baz_swig.baz_pow_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_pow_cc_sptr self)"""
        return _baz_swig.baz_pow_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_pow_cc_sptr self) -> bool"""
        return _baz_swig.baz_pow_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_pow_cc_sptr self, int m)"""
        return _baz_swig.baz_pow_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_pow_cc_sptr self) -> int"""
        return _baz_swig.baz_pow_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_pow_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_pow_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_pow_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_pow_cc_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_pow_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_pow_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_pow_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_pow_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_pow_cc_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_pow_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_pow_cc_sptr self, int which) -> float
        pc_input_buffers_full(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_pow_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_pow_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_pow_cc_sptr self, int which) -> float
        pc_output_buffers_full(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_pow_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_pow_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_pow_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_pow_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_pow_cc_sptr self) -> float"""
        return _baz_swig.baz_pow_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_pow_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_pow_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_pow_cc_sptr self)"""
        return _baz_swig.baz_pow_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_pow_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_pow_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_pow_cc_sptr self) -> int"""
        return _baz_swig.baz_pow_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_pow_cc_sptr self) -> int"""
        return _baz_swig.baz_pow_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_pow_cc_sptr self, int priority) -> int"""
        return _baz_swig.baz_pow_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_pow_cc_sptr self) -> std::string"""
        return _baz_swig.baz_pow_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_pow_cc_sptr self) -> std::string"""
        return _baz_swig.baz_pow_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_pow_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_pow_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_pow_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_pow_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_pow_cc_sptr self) -> long"""
        return _baz_swig.baz_pow_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_pow_cc_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_pow_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_pow_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_pow_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_pow_cc_sptr self) -> std::string"""
        return _baz_swig.baz_pow_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_pow_cc_sptr self, std::string name)"""
        return _baz_swig.baz_pow_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_pow_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_pow_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_pow_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_pow_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_pow_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_pow_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_pow_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_pow_cc_sptr_message_subscribers(self, which_port)

baz_pow_cc_sptr_swigregister = _baz_swig.baz_pow_cc_sptr_swigregister
baz_pow_cc_sptr_swigregister(baz_pow_cc_sptr)


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


def pow_cc(exponent, div_exp=0.0):
    """
    pow_cc(float exponent, float div_exp=0.0) -> baz_pow_cc_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_pow_cc.

    To avoid accidental use of raw pointers, baz_pow_cc's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (exponent, div_exp)
    """
    return _baz_swig.pow_cc(exponent, div_exp)
class baz_delay_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_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<(baz_delay)> self) -> baz_delay_sptr
        __init__(boost::shared_ptr<(baz_delay)> self, baz_delay * p) -> baz_delay_sptr
        """
        this = _baz_swig.new_baz_delay_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_delay_sptr self) -> baz_delay *"""
        return _baz_swig.baz_delay_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_delay_sptr
    __del__ = lambda self: None

    def delay(self):
        """
        delay(baz_delay_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.baz_delay_sptr_delay(self)


    def set_delay(self, delay):
        """
        set_delay(baz_delay_sptr self, int delay)



        Params: (delay)
        """
        return _baz_swig.baz_delay_sptr_set_delay(self, delay)


    def history(self):
        """history(baz_delay_sptr self) -> unsigned int"""
        return _baz_swig.baz_delay_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_delay_sptr self, int which, int delay)
        declare_sample_delay(baz_delay_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_delay_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_delay_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_delay_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_delay_sptr self) -> int"""
        return _baz_swig.baz_delay_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_delay_sptr self) -> double"""
        return _baz_swig.baz_delay_sptr_relative_rate(self)


    def start(self):
        """start(baz_delay_sptr self) -> bool"""
        return _baz_swig.baz_delay_sptr_start(self)


    def stop(self):
        """stop(baz_delay_sptr self) -> bool"""
        return _baz_swig.baz_delay_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_delay_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_delay_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_delay_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_delay_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_delay_sptr self) -> int"""
        return _baz_swig.baz_delay_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_delay_sptr self, int m)"""
        return _baz_swig.baz_delay_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_delay_sptr self)"""
        return _baz_swig.baz_delay_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_delay_sptr self) -> bool"""
        return _baz_swig.baz_delay_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_delay_sptr self, int m)"""
        return _baz_swig.baz_delay_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_delay_sptr self) -> int"""
        return _baz_swig.baz_delay_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_delay_sptr self, int i) -> long"""
        return _baz_swig.baz_delay_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_delay_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_delay_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_delay_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_delay_sptr self, int i) -> long"""
        return _baz_swig.baz_delay_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_delay_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_delay_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_delay_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_delay_sptr self, int which) -> float
        pc_input_buffers_full(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_delay_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_delay_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_delay_sptr self, int which) -> float
        pc_output_buffers_full(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_delay_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_delay_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_delay_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_delay_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_delay_sptr self) -> float"""
        return _baz_swig.baz_delay_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_delay_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_delay_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_delay_sptr self)"""
        return _baz_swig.baz_delay_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_delay_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_delay_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_delay_sptr self) -> int"""
        return _baz_swig.baz_delay_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_delay_sptr self) -> int"""
        return _baz_swig.baz_delay_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_delay_sptr self, int priority) -> int"""
        return _baz_swig.baz_delay_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_delay_sptr self) -> std::string"""
        return _baz_swig.baz_delay_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_delay_sptr self) -> std::string"""
        return _baz_swig.baz_delay_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_delay_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_delay_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_delay_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_delay_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_delay_sptr self) -> long"""
        return _baz_swig.baz_delay_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_delay_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_delay_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_delay_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_delay_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_delay_sptr self) -> std::string"""
        return _baz_swig.baz_delay_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_delay_sptr self, std::string name)"""
        return _baz_swig.baz_delay_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_delay_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_delay_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_delay_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_delay_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_delay_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_delay_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_delay_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_delay_sptr_message_subscribers(self, which_port)

baz_delay_sptr_swigregister = _baz_swig.baz_delay_sptr_swigregister
baz_delay_sptr_swigregister(baz_delay_sptr)


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


def delay(itemsize, delay):
    """
    delay(size_t itemsize, int delay) -> baz_delay_sptr

    delay the input by a certain number of samples

    Params: (itemsize, delay)
    """
    return _baz_swig.delay(itemsize, delay)
class baz_puncture_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_puncture_bb)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_puncture_bb)> self) -> baz_puncture_bb_sptr
        __init__(boost::shared_ptr<(baz_puncture_bb)> self, baz_puncture_bb * p) -> baz_puncture_bb_sptr
        """
        this = _baz_swig.new_baz_puncture_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_puncture_bb_sptr self) -> baz_puncture_bb *"""
        return _baz_swig.baz_puncture_bb_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_puncture_bb_sptr
    __del__ = lambda self: None

    def set_matrix(self, matrix):
        """
        set_matrix(baz_puncture_bb_sptr self, std::vector< int,std::allocator< int > > const & matrix)



        Params: (matrix)
        """
        return _baz_swig.baz_puncture_bb_sptr_set_matrix(self, matrix)


    def history(self):
        """history(baz_puncture_bb_sptr self) -> unsigned int"""
        return _baz_swig.baz_puncture_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_puncture_bb_sptr self, int which, int delay)
        declare_sample_delay(baz_puncture_bb_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_puncture_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_puncture_bb_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_puncture_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_puncture_bb_sptr self) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_puncture_bb_sptr self) -> double"""
        return _baz_swig.baz_puncture_bb_sptr_relative_rate(self)


    def start(self):
        """start(baz_puncture_bb_sptr self) -> bool"""
        return _baz_swig.baz_puncture_bb_sptr_start(self)


    def stop(self):
        """stop(baz_puncture_bb_sptr self) -> bool"""
        return _baz_swig.baz_puncture_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_puncture_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_puncture_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_puncture_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_puncture_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_puncture_bb_sptr self) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_puncture_bb_sptr self, int m)"""
        return _baz_swig.baz_puncture_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_puncture_bb_sptr self)"""
        return _baz_swig.baz_puncture_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_puncture_bb_sptr self) -> bool"""
        return _baz_swig.baz_puncture_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_puncture_bb_sptr self, int m)"""
        return _baz_swig.baz_puncture_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_puncture_bb_sptr self) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_puncture_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_puncture_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_puncture_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_puncture_bb_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_puncture_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_puncture_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_puncture_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_puncture_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_puncture_bb_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_puncture_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_puncture_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_puncture_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_puncture_bb_sptr self) -> float"""
        return _baz_swig.baz_puncture_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_puncture_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_puncture_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_puncture_bb_sptr self)"""
        return _baz_swig.baz_puncture_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_puncture_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_puncture_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_puncture_bb_sptr self) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_puncture_bb_sptr self) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_puncture_bb_sptr self, int priority) -> int"""
        return _baz_swig.baz_puncture_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_puncture_bb_sptr self) -> std::string"""
        return _baz_swig.baz_puncture_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_puncture_bb_sptr self) -> std::string"""
        return _baz_swig.baz_puncture_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_puncture_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_puncture_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_puncture_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_puncture_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_puncture_bb_sptr self) -> long"""
        return _baz_swig.baz_puncture_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_puncture_bb_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_puncture_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_puncture_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_puncture_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_puncture_bb_sptr self) -> std::string"""
        return _baz_swig.baz_puncture_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_puncture_bb_sptr self, std::string name)"""
        return _baz_swig.baz_puncture_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_puncture_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_puncture_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_puncture_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_puncture_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_puncture_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_puncture_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_puncture_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_puncture_bb_sptr_message_subscribers(self, which_port)

baz_puncture_bb_sptr_swigregister = _baz_swig.baz_puncture_bb_sptr_swigregister
baz_puncture_bb_sptr_swigregister(baz_puncture_bb_sptr)


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


def puncture_bb(matrix):
    """
    puncture_bb(std::vector< int,std::allocator< int > > const & matrix) -> baz_puncture_bb_sptr

    square a stream of floats.

    Return a shared_ptr to a new instance of baz_puncture_bb.

    To avoid accidental use of raw pointers, baz_puncture_bb's constructor is private. baz_make_puncture_bb is the public interface for creating new instances.

    Params: (matrix)
    """
    return _baz_swig.puncture_bb(matrix)
class baz_depuncture_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_depuncture_ff)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_depuncture_ff)> self) -> baz_depuncture_ff_sptr
        __init__(boost::shared_ptr<(baz_depuncture_ff)> self, baz_depuncture_ff * p) -> baz_depuncture_ff_sptr
        """
        this = _baz_swig.new_baz_depuncture_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_depuncture_ff_sptr self) -> baz_depuncture_ff *"""
        return _baz_swig.baz_depuncture_ff_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_depuncture_ff_sptr
    __del__ = lambda self: None

    def set_matrix(self, matrix):
        """
        set_matrix(baz_depuncture_ff_sptr self, std::vector< int,std::allocator< int > > const & matrix)



        Params: (matrix)
        """
        return _baz_swig.baz_depuncture_ff_sptr_set_matrix(self, matrix)


    def history(self):
        """history(baz_depuncture_ff_sptr self) -> unsigned int"""
        return _baz_swig.baz_depuncture_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_depuncture_ff_sptr self, int which, int delay)
        declare_sample_delay(baz_depuncture_ff_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_depuncture_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_depuncture_ff_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_depuncture_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_depuncture_ff_sptr self) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_depuncture_ff_sptr self) -> double"""
        return _baz_swig.baz_depuncture_ff_sptr_relative_rate(self)


    def start(self):
        """start(baz_depuncture_ff_sptr self) -> bool"""
        return _baz_swig.baz_depuncture_ff_sptr_start(self)


    def stop(self):
        """stop(baz_depuncture_ff_sptr self) -> bool"""
        return _baz_swig.baz_depuncture_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_depuncture_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_depuncture_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_depuncture_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_depuncture_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_depuncture_ff_sptr self) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_depuncture_ff_sptr self, int m)"""
        return _baz_swig.baz_depuncture_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_depuncture_ff_sptr self)"""
        return _baz_swig.baz_depuncture_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_depuncture_ff_sptr self) -> bool"""
        return _baz_swig.baz_depuncture_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_depuncture_ff_sptr self, int m)"""
        return _baz_swig.baz_depuncture_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_depuncture_ff_sptr self) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_depuncture_ff_sptr self, int i) -> long"""
        return _baz_swig.baz_depuncture_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_depuncture_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_depuncture_ff_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_depuncture_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_depuncture_ff_sptr self, int i) -> long"""
        return _baz_swig.baz_depuncture_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_depuncture_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_depuncture_ff_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_depuncture_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_depuncture_ff_sptr self, int which) -> float
        pc_input_buffers_full(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_depuncture_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_depuncture_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_depuncture_ff_sptr self, int which) -> float
        pc_output_buffers_full(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_depuncture_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_depuncture_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_depuncture_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_depuncture_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_depuncture_ff_sptr self) -> float"""
        return _baz_swig.baz_depuncture_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_depuncture_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_depuncture_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_depuncture_ff_sptr self)"""
        return _baz_swig.baz_depuncture_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_depuncture_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_depuncture_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_depuncture_ff_sptr self) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_depuncture_ff_sptr self) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_depuncture_ff_sptr self, int priority) -> int"""
        return _baz_swig.baz_depuncture_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_depuncture_ff_sptr self) -> std::string"""
        return _baz_swig.baz_depuncture_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_depuncture_ff_sptr self) -> std::string"""
        return _baz_swig.baz_depuncture_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_depuncture_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_depuncture_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_depuncture_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_depuncture_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_depuncture_ff_sptr self) -> long"""
        return _baz_swig.baz_depuncture_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_depuncture_ff_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_depuncture_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_depuncture_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_depuncture_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_depuncture_ff_sptr self) -> std::string"""
        return _baz_swig.baz_depuncture_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_depuncture_ff_sptr self, std::string name)"""
        return _baz_swig.baz_depuncture_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_depuncture_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_depuncture_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_depuncture_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_depuncture_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_depuncture_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_depuncture_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_depuncture_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_depuncture_ff_sptr_message_subscribers(self, which_port)

baz_depuncture_ff_sptr_swigregister = _baz_swig.baz_depuncture_ff_sptr_swigregister
baz_depuncture_ff_sptr_swigregister(baz_depuncture_ff_sptr)


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


def depuncture_ff(matrix):
    """
    depuncture_ff(std::vector< int,std::allocator< int > > const & matrix) -> baz_depuncture_ff_sptr

    square a stream of floats.

    Return a shared_ptr to a new instance of baz_depuncture_ff.

    To avoid accidental use of raw pointers, baz_depuncture_ff's constructor is private. baz_make_depuncture_ff is the public interface for creating new instances.

    Params: (matrix)
    """
    return _baz_swig.depuncture_ff(matrix)
class baz_swap_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_swap_ff)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_swap_ff)> self) -> baz_swap_ff_sptr
        __init__(boost::shared_ptr<(baz_swap_ff)> self, baz_swap_ff * p) -> baz_swap_ff_sptr
        """
        this = _baz_swig.new_baz_swap_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_swap_ff_sptr self) -> baz_swap_ff *"""
        return _baz_swig.baz_swap_ff_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_swap_ff_sptr
    __del__ = lambda self: None

    def set_swap(self, bSwap):
        """
        set_swap(baz_swap_ff_sptr self, bool bSwap)



        Params: (bSwap)
        """
        return _baz_swig.baz_swap_ff_sptr_set_swap(self, bSwap)


    def history(self):
        """history(baz_swap_ff_sptr self) -> unsigned int"""
        return _baz_swig.baz_swap_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_swap_ff_sptr self, int which, int delay)
        declare_sample_delay(baz_swap_ff_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_swap_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_swap_ff_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_swap_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_swap_ff_sptr self) -> int"""
        return _baz_swig.baz_swap_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_swap_ff_sptr self) -> double"""
        return _baz_swig.baz_swap_ff_sptr_relative_rate(self)


    def start(self):
        """start(baz_swap_ff_sptr self) -> bool"""
        return _baz_swig.baz_swap_ff_sptr_start(self)


    def stop(self):
        """stop(baz_swap_ff_sptr self) -> bool"""
        return _baz_swig.baz_swap_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_swap_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_swap_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_swap_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_swap_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_swap_ff_sptr self) -> int"""
        return _baz_swig.baz_swap_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_swap_ff_sptr self, int m)"""
        return _baz_swig.baz_swap_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_swap_ff_sptr self)"""
        return _baz_swig.baz_swap_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_swap_ff_sptr self) -> bool"""
        return _baz_swig.baz_swap_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_swap_ff_sptr self, int m)"""
        return _baz_swig.baz_swap_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_swap_ff_sptr self) -> int"""
        return _baz_swig.baz_swap_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_swap_ff_sptr self, int i) -> long"""
        return _baz_swig.baz_swap_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_swap_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_swap_ff_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_swap_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_swap_ff_sptr self, int i) -> long"""
        return _baz_swig.baz_swap_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_swap_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_swap_ff_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_swap_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_swap_ff_sptr self, int which) -> float
        pc_input_buffers_full(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_swap_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_swap_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_swap_ff_sptr self, int which) -> float
        pc_output_buffers_full(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_swap_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_swap_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_swap_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_swap_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_swap_ff_sptr self) -> float"""
        return _baz_swig.baz_swap_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_swap_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_swap_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_swap_ff_sptr self)"""
        return _baz_swig.baz_swap_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_swap_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_swap_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_swap_ff_sptr self) -> int"""
        return _baz_swig.baz_swap_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_swap_ff_sptr self) -> int"""
        return _baz_swig.baz_swap_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_swap_ff_sptr self, int priority) -> int"""
        return _baz_swig.baz_swap_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_swap_ff_sptr self) -> std::string"""
        return _baz_swig.baz_swap_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_swap_ff_sptr self) -> std::string"""
        return _baz_swig.baz_swap_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_swap_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_swap_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_swap_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_swap_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_swap_ff_sptr self) -> long"""
        return _baz_swig.baz_swap_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_swap_ff_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_swap_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_swap_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_swap_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_swap_ff_sptr self) -> std::string"""
        return _baz_swig.baz_swap_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_swap_ff_sptr self, std::string name)"""
        return _baz_swig.baz_swap_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_swap_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_swap_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_swap_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_swap_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_swap_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_swap_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_swap_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_swap_ff_sptr_message_subscribers(self, which_port)

baz_swap_ff_sptr_swigregister = _baz_swig.baz_swap_ff_sptr_swigregister
baz_swap_ff_sptr_swigregister(baz_swap_ff_sptr)


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


def swap_ff(bSwap):
    """
    swap_ff(bool bSwap) -> baz_swap_ff_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_swap_ff.

    To avoid accidental use of raw pointers, baz_swap_ff's constructor is private. baz_make_swap_ff is the public interface for creating new instances.

    Params: (bSwap)
    """
    return _baz_swig.swap_ff(bSwap)
class baz_agc_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_agc_cc)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_agc_cc)> self) -> baz_agc_cc_sptr
        __init__(boost::shared_ptr<(baz_agc_cc)> self, baz_agc_cc * p) -> baz_agc_cc_sptr
        """
        this = _baz_swig.new_baz_agc_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_agc_cc_sptr self) -> baz_agc_cc *"""
        return _baz_swig.baz_agc_cc_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_agc_cc_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_agc_cc_sptr self) -> unsigned int"""
        return _baz_swig.baz_agc_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_agc_cc_sptr self, int which, int delay)
        declare_sample_delay(baz_agc_cc_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_agc_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_agc_cc_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_agc_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_agc_cc_sptr self) -> int"""
        return _baz_swig.baz_agc_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_agc_cc_sptr self) -> double"""
        return _baz_swig.baz_agc_cc_sptr_relative_rate(self)


    def start(self):
        """start(baz_agc_cc_sptr self) -> bool"""
        return _baz_swig.baz_agc_cc_sptr_start(self)


    def stop(self):
        """stop(baz_agc_cc_sptr self) -> bool"""
        return _baz_swig.baz_agc_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_agc_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_agc_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_agc_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_agc_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_agc_cc_sptr self) -> int"""
        return _baz_swig.baz_agc_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_agc_cc_sptr self, int m)"""
        return _baz_swig.baz_agc_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_agc_cc_sptr self)"""
        return _baz_swig.baz_agc_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_agc_cc_sptr self) -> bool"""
        return _baz_swig.baz_agc_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_agc_cc_sptr self, int m)"""
        return _baz_swig.baz_agc_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_agc_cc_sptr self) -> int"""
        return _baz_swig.baz_agc_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_agc_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_agc_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_agc_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_agc_cc_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_agc_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_agc_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_agc_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_agc_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_agc_cc_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_agc_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_agc_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_agc_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_agc_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_agc_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_agc_cc_sptr self) -> float"""
        return _baz_swig.baz_agc_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_agc_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_agc_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_agc_cc_sptr self)"""
        return _baz_swig.baz_agc_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_agc_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_agc_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_agc_cc_sptr self) -> int"""
        return _baz_swig.baz_agc_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_agc_cc_sptr self) -> int"""
        return _baz_swig.baz_agc_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_agc_cc_sptr self, int priority) -> int"""
        return _baz_swig.baz_agc_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_agc_cc_sptr self) -> std::string"""
        return _baz_swig.baz_agc_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_agc_cc_sptr self) -> std::string"""
        return _baz_swig.baz_agc_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_agc_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_agc_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_agc_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_agc_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_agc_cc_sptr self) -> long"""
        return _baz_swig.baz_agc_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_agc_cc_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_agc_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_agc_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_agc_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_agc_cc_sptr self) -> std::string"""
        return _baz_swig.baz_agc_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_agc_cc_sptr self, std::string name)"""
        return _baz_swig.baz_agc_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_agc_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_agc_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_agc_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_agc_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_agc_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_agc_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_agc_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_agc_cc_sptr_message_subscribers(self, which_port)

baz_agc_cc_sptr_swigregister = _baz_swig.baz_agc_cc_sptr_swigregister
baz_agc_cc_sptr_swigregister(baz_agc_cc_sptr)


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


def agc_cc(rate=1e-4, reference=1.0, gain=1.0, max_gain=0.0):
    """
    agc_cc(float rate=1e-4, float reference=1.0, float gain=1.0, float max_gain=0.0) -> baz_agc_cc_sptr

    high performance Automatic Gain Control class

    For Power the absolute value of the complex number is used.

    Params: (rate, reference, gain, max_gain)
    """
    return _baz_swig.agc_cc(rate, reference, gain, max_gain)
class baz_test_counter_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_test_counter_cc)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_test_counter_cc)> self) -> baz_test_counter_cc_sptr
        __init__(boost::shared_ptr<(baz_test_counter_cc)> self, baz_test_counter_cc * p) -> baz_test_counter_cc_sptr
        """
        this = _baz_swig.new_baz_test_counter_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_test_counter_cc_sptr self) -> baz_test_counter_cc *"""
        return _baz_swig.baz_test_counter_cc_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_test_counter_cc_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_test_counter_cc_sptr self) -> unsigned int"""
        return _baz_swig.baz_test_counter_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_test_counter_cc_sptr self, int which, int delay)
        declare_sample_delay(baz_test_counter_cc_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_test_counter_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_test_counter_cc_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_test_counter_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_test_counter_cc_sptr self) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_test_counter_cc_sptr self) -> double"""
        return _baz_swig.baz_test_counter_cc_sptr_relative_rate(self)


    def start(self):
        """start(baz_test_counter_cc_sptr self) -> bool"""
        return _baz_swig.baz_test_counter_cc_sptr_start(self)


    def stop(self):
        """stop(baz_test_counter_cc_sptr self) -> bool"""
        return _baz_swig.baz_test_counter_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_test_counter_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_test_counter_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_test_counter_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_test_counter_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_test_counter_cc_sptr self) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_test_counter_cc_sptr self, int m)"""
        return _baz_swig.baz_test_counter_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_test_counter_cc_sptr self)"""
        return _baz_swig.baz_test_counter_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_test_counter_cc_sptr self) -> bool"""
        return _baz_swig.baz_test_counter_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_test_counter_cc_sptr self, int m)"""
        return _baz_swig.baz_test_counter_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_test_counter_cc_sptr self) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_test_counter_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_test_counter_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_test_counter_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_test_counter_cc_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_test_counter_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_test_counter_cc_sptr self, int i) -> long"""
        return _baz_swig.baz_test_counter_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_test_counter_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_test_counter_cc_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_test_counter_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_test_counter_cc_sptr self, int which) -> float
        pc_input_buffers_full(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_test_counter_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_test_counter_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_test_counter_cc_sptr self, int which) -> float
        pc_output_buffers_full(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_test_counter_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_test_counter_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_test_counter_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_test_counter_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_test_counter_cc_sptr self) -> float"""
        return _baz_swig.baz_test_counter_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_test_counter_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_test_counter_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_test_counter_cc_sptr self)"""
        return _baz_swig.baz_test_counter_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_test_counter_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_test_counter_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_test_counter_cc_sptr self) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_test_counter_cc_sptr self) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_test_counter_cc_sptr self, int priority) -> int"""
        return _baz_swig.baz_test_counter_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_test_counter_cc_sptr self) -> std::string"""
        return _baz_swig.baz_test_counter_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_test_counter_cc_sptr self) -> std::string"""
        return _baz_swig.baz_test_counter_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_test_counter_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_test_counter_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_test_counter_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_test_counter_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_test_counter_cc_sptr self) -> long"""
        return _baz_swig.baz_test_counter_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_test_counter_cc_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_test_counter_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_test_counter_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_test_counter_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_test_counter_cc_sptr self) -> std::string"""
        return _baz_swig.baz_test_counter_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_test_counter_cc_sptr self, std::string name)"""
        return _baz_swig.baz_test_counter_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_test_counter_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_test_counter_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_test_counter_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_test_counter_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_test_counter_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_test_counter_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_test_counter_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_test_counter_cc_sptr_message_subscribers(self, which_port)

baz_test_counter_cc_sptr_swigregister = _baz_swig.baz_test_counter_cc_sptr_swigregister
baz_test_counter_cc_sptr_swigregister(baz_test_counter_cc_sptr)


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


def test_counter_cc():
    """
    test_counter_cc() -> baz_test_counter_cc_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_test_counter_cc.

    To avoid accidental use of raw pointers, baz_test_counter_cc's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (NONE)
    """
    return _baz_swig.test_counter_cc()
class baz_udp_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_udp_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<(baz_udp_source)> self) -> baz_udp_source_sptr
        __init__(boost::shared_ptr<(baz_udp_source)> self, baz_udp_source * p) -> baz_udp_source_sptr
        """
        this = _baz_swig.new_baz_udp_source_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_udp_source_sptr self) -> baz_udp_source *"""
        return _baz_swig.baz_udp_source_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_udp_source_sptr
    __del__ = lambda self: None

    def payload_size(self):
        """payload_size(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_payload_size(self)


    def get_port(self):
        """get_port(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_get_port(self)


    def signal_eos(self):
        """signal_eos(baz_udp_source_sptr self)"""
        return _baz_swig.baz_udp_source_sptr_signal_eos(self)


    def history(self):
        """history(baz_udp_source_sptr self) -> unsigned int"""
        return _baz_swig.baz_udp_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_udp_source_sptr self, int which, int delay)
        declare_sample_delay(baz_udp_source_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_udp_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_udp_source_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_udp_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_udp_source_sptr self) -> double"""
        return _baz_swig.baz_udp_source_sptr_relative_rate(self)


    def start(self):
        """start(baz_udp_source_sptr self) -> bool"""
        return _baz_swig.baz_udp_source_sptr_start(self)


    def stop(self):
        """stop(baz_udp_source_sptr self) -> bool"""
        return _baz_swig.baz_udp_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_udp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_udp_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_udp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_udp_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_udp_source_sptr self, int m)"""
        return _baz_swig.baz_udp_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_udp_source_sptr self)"""
        return _baz_swig.baz_udp_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_udp_source_sptr self) -> bool"""
        return _baz_swig.baz_udp_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_udp_source_sptr self, int m)"""
        return _baz_swig.baz_udp_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_udp_source_sptr self, int i) -> long"""
        return _baz_swig.baz_udp_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_udp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_udp_source_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_udp_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_udp_source_sptr self, int i) -> long"""
        return _baz_swig.baz_udp_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_udp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_udp_source_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_udp_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_udp_source_sptr self, int which) -> float
        pc_input_buffers_full(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_udp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_udp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_udp_source_sptr self, int which) -> float
        pc_output_buffers_full(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_udp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_udp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_udp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_udp_source_sptr self) -> float"""
        return _baz_swig.baz_udp_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_udp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_udp_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_udp_source_sptr self)"""
        return _baz_swig.baz_udp_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_udp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_udp_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_udp_source_sptr self) -> int"""
        return _baz_swig.baz_udp_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_udp_source_sptr self, int priority) -> int"""
        return _baz_swig.baz_udp_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_udp_source_sptr self) -> std::string"""
        return _baz_swig.baz_udp_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_udp_source_sptr self) -> std::string"""
        return _baz_swig.baz_udp_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_udp_source_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_udp_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_udp_source_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_udp_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_udp_source_sptr self) -> long"""
        return _baz_swig.baz_udp_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_udp_source_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_udp_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_udp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_udp_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_udp_source_sptr self) -> std::string"""
        return _baz_swig.baz_udp_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_udp_source_sptr self, std::string name)"""
        return _baz_swig.baz_udp_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_udp_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_udp_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_udp_source_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_udp_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_udp_source_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_udp_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_udp_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_udp_source_sptr_message_subscribers(self, which_port)

baz_udp_source_sptr_swigregister = _baz_swig.baz_udp_source_sptr_swigregister
baz_udp_source_sptr_swigregister(baz_udp_source_sptr)


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


def udp_source(itemsize, host, port, payload_size=1472, eof=True, wait=True, bor=False, verbose=False, buf_size=0, mode=-1):
    """udp_source(size_t itemsize, char const * host, unsigned short port, int payload_size=1472, bool eof=True, bool wait=True, bool bor=False, bool verbose=False, size_t buf_size=0, int mode=-1) -> baz_udp_source_sptr"""
    return _baz_swig.udp_source(itemsize, host, port, payload_size, eof, wait, bor, verbose, buf_size, mode)
class baz_udp_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_udp_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<(baz_udp_sink)> self) -> baz_udp_sink_sptr
        __init__(boost::shared_ptr<(baz_udp_sink)> self, baz_udp_sink * p) -> baz_udp_sink_sptr
        """
        this = _baz_swig.new_baz_udp_sink_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_udp_sink_sptr self) -> baz_udp_sink *"""
        return _baz_swig.baz_udp_sink_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_udp_sink_sptr
    __del__ = lambda self: None

    def payload_size(self):
        """payload_size(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_payload_size(self)


    def connect(self, host, port):
        """connect(baz_udp_sink_sptr self, char const * host, unsigned short port)"""
        return _baz_swig.baz_udp_sink_sptr_connect(self, host, port)


    def disconnect(self):
        """disconnect(baz_udp_sink_sptr self)"""
        return _baz_swig.baz_udp_sink_sptr_disconnect(self)


    def set_borip(self, enable):
        """set_borip(baz_udp_sink_sptr self, bool enable)"""
        return _baz_swig.baz_udp_sink_sptr_set_borip(self, enable)


    def set_payload_size(self, payload_size):
        """set_payload_size(baz_udp_sink_sptr self, int payload_size)"""
        return _baz_swig.baz_udp_sink_sptr_set_payload_size(self, payload_size)


    def set_status_msgq(self, queue):
        """set_status_msgq(baz_udp_sink_sptr self, msg_queue_sptr queue)"""
        return _baz_swig.baz_udp_sink_sptr_set_status_msgq(self, queue)


    def history(self):
        """history(baz_udp_sink_sptr self) -> unsigned int"""
        return _baz_swig.baz_udp_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_udp_sink_sptr self, int which, int delay)
        declare_sample_delay(baz_udp_sink_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_udp_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_udp_sink_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_udp_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_udp_sink_sptr self) -> double"""
        return _baz_swig.baz_udp_sink_sptr_relative_rate(self)


    def start(self):
        """start(baz_udp_sink_sptr self) -> bool"""
        return _baz_swig.baz_udp_sink_sptr_start(self)


    def stop(self):
        """stop(baz_udp_sink_sptr self) -> bool"""
        return _baz_swig.baz_udp_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_udp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_udp_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_udp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_udp_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_udp_sink_sptr self, int m)"""
        return _baz_swig.baz_udp_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_udp_sink_sptr self)"""
        return _baz_swig.baz_udp_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_udp_sink_sptr self) -> bool"""
        return _baz_swig.baz_udp_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_udp_sink_sptr self, int m)"""
        return _baz_swig.baz_udp_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_udp_sink_sptr self, int i) -> long"""
        return _baz_swig.baz_udp_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_udp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_udp_sink_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_udp_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_udp_sink_sptr self, int i) -> long"""
        return _baz_swig.baz_udp_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_udp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_udp_sink_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_udp_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_udp_sink_sptr self, int which) -> float
        pc_input_buffers_full(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_udp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_udp_sink_sptr self, int which) -> float
        pc_output_buffers_full(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_udp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_udp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_udp_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_udp_sink_sptr self) -> float"""
        return _baz_swig.baz_udp_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_udp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_udp_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_udp_sink_sptr self)"""
        return _baz_swig.baz_udp_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_udp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_udp_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_udp_sink_sptr self) -> int"""
        return _baz_swig.baz_udp_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_udp_sink_sptr self, int priority) -> int"""
        return _baz_swig.baz_udp_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_udp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_udp_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_udp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_udp_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_udp_sink_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_udp_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_udp_sink_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_udp_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_udp_sink_sptr self) -> long"""
        return _baz_swig.baz_udp_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_udp_sink_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_udp_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_udp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_udp_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_udp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_udp_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_udp_sink_sptr self, std::string name)"""
        return _baz_swig.baz_udp_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_udp_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_udp_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_udp_sink_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_udp_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_udp_sink_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_udp_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_udp_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_udp_sink_sptr_message_subscribers(self, which_port)

baz_udp_sink_sptr_swigregister = _baz_swig.baz_udp_sink_sptr_swigregister
baz_udp_sink_sptr_swigregister(baz_udp_sink_sptr)


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


def udp_sink(itemsize, host, port, payload_size=1472, eof=True, bor=False):
    """udp_sink(size_t itemsize, char const * host, unsigned short port, int payload_size=1472, bool eof=True, bool bor=False) -> baz_udp_sink_sptr"""
    return _baz_swig.udp_sink(itemsize, host, port, payload_size, eof, bor)
class baz_native_callback_target(object):
    """Proxy of C++ baz_native_callback_target 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 callback(self, f, samples_processed):
        """
        callback(baz_native_callback_target self, float f, unsigned long samples_processed)



        Params: (f, samples_processed)
        """
        return _baz_swig.baz_native_callback_target_callback(self, f, samples_processed)

    __swig_destroy__ = _baz_swig.delete_baz_native_callback_target
    __del__ = lambda self: None
baz_native_callback_target_swigregister = _baz_swig.baz_native_callback_target_swigregister
baz_native_callback_target_swigregister(baz_native_callback_target)

class baz_native_callback_x_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_native_callback_x)> class."""

    thisown = _swig_property(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<(baz_native_callback_x)> self) -> baz_native_callback_x_sptr
        __init__(boost::shared_ptr<(baz_native_callback_x)> self, baz_native_callback_x * p) -> baz_native_callback_x_sptr
        """
        this = _baz_swig.new_baz_native_callback_x_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_native_callback_x_sptr self) -> baz_native_callback_x *"""
        return _baz_swig.baz_native_callback_x_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_native_callback_x_sptr
    __del__ = lambda self: None

    def set_size(self, size):
        """
        set_size(baz_native_callback_x_sptr self, int size)



        Params: (size)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_size(self, size)


    def set_target(self, target):
        """
        set_target(baz_native_callback_x_sptr self, basic_block_sptr target)



        Params: (target)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_target(self, target)


    def set_threshold_enable(self, enable):
        """
        set_threshold_enable(baz_native_callback_x_sptr self, bool enable)



        Params: (enable)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_threshold_enable(self, enable)


    def set_threshold_level(self, threshold_level):
        """
        set_threshold_level(baz_native_callback_x_sptr self, float threshold_level)



        Params: (threshold_level)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_threshold_level(self, threshold_level)


    def size(self):
        """
        size(baz_native_callback_x_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.baz_native_callback_x_sptr_size(self)


    def threshold_enable(self):
        """
        threshold_enable(baz_native_callback_x_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_native_callback_x_sptr_threshold_enable(self)


    def threshold_level(self):
        """
        threshold_level(baz_native_callback_x_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_native_callback_x_sptr_threshold_level(self)


    def history(self):
        """history(baz_native_callback_x_sptr self) -> unsigned int"""
        return _baz_swig.baz_native_callback_x_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_native_callback_x_sptr self, int which, int delay)
        declare_sample_delay(baz_native_callback_x_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_native_callback_x_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_native_callback_x_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_native_callback_x_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_native_callback_x_sptr self) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_native_callback_x_sptr self) -> double"""
        return _baz_swig.baz_native_callback_x_sptr_relative_rate(self)


    def start(self):
        """start(baz_native_callback_x_sptr self) -> bool"""
        return _baz_swig.baz_native_callback_x_sptr_start(self)


    def stop(self):
        """stop(baz_native_callback_x_sptr self) -> bool"""
        return _baz_swig.baz_native_callback_x_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_native_callback_x_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_native_callback_x_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_native_callback_x_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_native_callback_x_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_native_callback_x_sptr self) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_native_callback_x_sptr self, int m)"""
        return _baz_swig.baz_native_callback_x_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_native_callback_x_sptr self)"""
        return _baz_swig.baz_native_callback_x_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_native_callback_x_sptr self) -> bool"""
        return _baz_swig.baz_native_callback_x_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_native_callback_x_sptr self, int m)"""
        return _baz_swig.baz_native_callback_x_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_native_callback_x_sptr self) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_native_callback_x_sptr self, int i) -> long"""
        return _baz_swig.baz_native_callback_x_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_native_callback_x_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_native_callback_x_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_native_callback_x_sptr self, int i) -> long"""
        return _baz_swig.baz_native_callback_x_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_native_callback_x_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_native_callback_x_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_native_callback_x_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_native_callback_x_sptr self, int which) -> float
        pc_input_buffers_full(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_native_callback_x_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_native_callback_x_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_native_callback_x_sptr self, int which) -> float
        pc_output_buffers_full(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_native_callback_x_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_native_callback_x_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_native_callback_x_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_callback_x_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_native_callback_x_sptr self) -> float"""
        return _baz_swig.baz_native_callback_x_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_native_callback_x_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_native_callback_x_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_native_callback_x_sptr self)"""
        return _baz_swig.baz_native_callback_x_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_native_callback_x_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_native_callback_x_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_native_callback_x_sptr self) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_native_callback_x_sptr self) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_native_callback_x_sptr self, int priority) -> int"""
        return _baz_swig.baz_native_callback_x_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_native_callback_x_sptr self) -> std::string"""
        return _baz_swig.baz_native_callback_x_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_native_callback_x_sptr self) -> std::string"""
        return _baz_swig.baz_native_callback_x_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_native_callback_x_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_native_callback_x_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_native_callback_x_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_native_callback_x_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_native_callback_x_sptr self) -> long"""
        return _baz_swig.baz_native_callback_x_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_native_callback_x_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_native_callback_x_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_native_callback_x_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_native_callback_x_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_native_callback_x_sptr self) -> std::string"""
        return _baz_swig.baz_native_callback_x_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_native_callback_x_sptr self, std::string name)"""
        return _baz_swig.baz_native_callback_x_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_native_callback_x_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_native_callback_x_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_native_callback_x_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_native_callback_x_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_native_callback_x_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_native_callback_x_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_native_callback_x_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_native_callback_x_sptr_message_subscribers(self, which_port)

baz_native_callback_x_sptr_swigregister = _baz_swig.baz_native_callback_x_sptr_swigregister
baz_native_callback_x_sptr_swigregister(baz_native_callback_x_sptr)


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


def native_callback_x(size, target, threshold_enable=False, threshold_level=0.0):
    """
    native_callback_x(int size, basic_block_sptr target, bool threshold_enable=False, float threshold_level=0.0) -> baz_native_callback_x_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_native_callback_x.

    To avoid accidental use of raw pointers, baz_native_callback_x's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (size, target, threshold_enable, threshold_level)
    """
    return _baz_swig.native_callback_x(size, target, threshold_enable, threshold_level)
class baz_native_mux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_native_mux)> class."""

    thisown = _swig_property(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<(baz_native_mux)> self) -> baz_native_mux_sptr
        __init__(boost::shared_ptr<(baz_native_mux)> self, baz_native_mux * p) -> baz_native_mux_sptr
        """
        this = _baz_swig.new_baz_native_mux_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_native_mux_sptr self) -> baz_native_mux *"""
        return _baz_swig.baz_native_mux_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_native_mux_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_native_mux_sptr self) -> unsigned int"""
        return _baz_swig.baz_native_mux_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_native_mux_sptr self, int which, int delay)
        declare_sample_delay(baz_native_mux_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_native_mux_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_native_mux_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_native_mux_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_native_mux_sptr self) -> int"""
        return _baz_swig.baz_native_mux_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_native_mux_sptr self) -> double"""
        return _baz_swig.baz_native_mux_sptr_relative_rate(self)


    def start(self):
        """start(baz_native_mux_sptr self) -> bool"""
        return _baz_swig.baz_native_mux_sptr_start(self)


    def stop(self):
        """stop(baz_native_mux_sptr self) -> bool"""
        return _baz_swig.baz_native_mux_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_native_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_native_mux_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_native_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_native_mux_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_native_mux_sptr self) -> int"""
        return _baz_swig.baz_native_mux_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_native_mux_sptr self, int m)"""
        return _baz_swig.baz_native_mux_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_native_mux_sptr self)"""
        return _baz_swig.baz_native_mux_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_native_mux_sptr self) -> bool"""
        return _baz_swig.baz_native_mux_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_native_mux_sptr self, int m)"""
        return _baz_swig.baz_native_mux_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_native_mux_sptr self) -> int"""
        return _baz_swig.baz_native_mux_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_native_mux_sptr self, int i) -> long"""
        return _baz_swig.baz_native_mux_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_native_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_native_mux_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_native_mux_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_native_mux_sptr self, int i) -> long"""
        return _baz_swig.baz_native_mux_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_native_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_native_mux_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_native_mux_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_native_mux_sptr self, int which) -> float
        pc_input_buffers_full(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_native_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_native_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_native_mux_sptr self, int which) -> float
        pc_output_buffers_full(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_native_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_native_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_native_mux_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_native_mux_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_native_mux_sptr self) -> float"""
        return _baz_swig.baz_native_mux_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_native_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_native_mux_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_native_mux_sptr self)"""
        return _baz_swig.baz_native_mux_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_native_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_native_mux_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_native_mux_sptr self) -> int"""
        return _baz_swig.baz_native_mux_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_native_mux_sptr self) -> int"""
        return _baz_swig.baz_native_mux_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_native_mux_sptr self, int priority) -> int"""
        return _baz_swig.baz_native_mux_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_native_mux_sptr self) -> std::string"""
        return _baz_swig.baz_native_mux_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_native_mux_sptr self) -> std::string"""
        return _baz_swig.baz_native_mux_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_native_mux_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_native_mux_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_native_mux_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_native_mux_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_native_mux_sptr self) -> long"""
        return _baz_swig.baz_native_mux_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_native_mux_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_native_mux_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_native_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_native_mux_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_native_mux_sptr self) -> std::string"""
        return _baz_swig.baz_native_mux_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_native_mux_sptr self, std::string name)"""
        return _baz_swig.baz_native_mux_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_native_mux_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_native_mux_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_native_mux_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_native_mux_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_native_mux_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_native_mux_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_native_mux_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_native_mux_sptr_message_subscribers(self, which_port)


    def callback(self, f, samples_processed):
        """
        callback(baz_native_mux_sptr self, float f, unsigned long samples_processed)



        Params: (f, samples_processed)
        """
        return _baz_swig.baz_native_mux_sptr_callback(self, f, samples_processed)

baz_native_mux_sptr_swigregister = _baz_swig.baz_native_mux_sptr_swigregister
baz_native_mux_sptr_swigregister(baz_native_mux_sptr)


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


def native_mux(item_size, input_count, trigger_count=-1):
    """
    native_mux(int item_size, int input_count, int trigger_count=-1) -> baz_native_mux_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_native_mux.

    To avoid accidental use of raw pointers, baz_native_mux's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, input_count, trigger_count)
    """
    return _baz_swig.native_mux(item_size, input_count, trigger_count)
class baz_block_status_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_block_status)> class."""

    thisown = _swig_property(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<(baz_block_status)> self) -> baz_block_status_sptr
        __init__(boost::shared_ptr<(baz_block_status)> self, baz_block_status * p) -> baz_block_status_sptr
        """
        this = _baz_swig.new_baz_block_status_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_block_status_sptr self) -> baz_block_status *"""
        return _baz_swig.baz_block_status_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_block_status_sptr
    __del__ = lambda self: None

    def set_size(self, size):
        """
        set_size(baz_block_status_sptr self, int size)



        Params: (size)
        """
        return _baz_swig.baz_block_status_sptr_set_size(self, size)


    def size(self):
        """
        size(baz_block_status_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.baz_block_status_sptr_size(self)


    def history(self):
        """history(baz_block_status_sptr self) -> unsigned int"""
        return _baz_swig.baz_block_status_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_block_status_sptr self, int which, int delay)
        declare_sample_delay(baz_block_status_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_block_status_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_block_status_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_block_status_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_block_status_sptr self) -> int"""
        return _baz_swig.baz_block_status_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_block_status_sptr self) -> double"""
        return _baz_swig.baz_block_status_sptr_relative_rate(self)


    def start(self):
        """start(baz_block_status_sptr self) -> bool"""
        return _baz_swig.baz_block_status_sptr_start(self)


    def stop(self):
        """stop(baz_block_status_sptr self) -> bool"""
        return _baz_swig.baz_block_status_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_block_status_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_block_status_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_block_status_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_block_status_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_block_status_sptr self) -> int"""
        return _baz_swig.baz_block_status_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_block_status_sptr self, int m)"""
        return _baz_swig.baz_block_status_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_block_status_sptr self)"""
        return _baz_swig.baz_block_status_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_block_status_sptr self) -> bool"""
        return _baz_swig.baz_block_status_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_block_status_sptr self, int m)"""
        return _baz_swig.baz_block_status_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_block_status_sptr self) -> int"""
        return _baz_swig.baz_block_status_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_block_status_sptr self, int i) -> long"""
        return _baz_swig.baz_block_status_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_block_status_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_block_status_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_block_status_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_block_status_sptr self, int i) -> long"""
        return _baz_swig.baz_block_status_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_block_status_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_block_status_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_block_status_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_block_status_sptr self, int which) -> float
        pc_input_buffers_full(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_block_status_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_block_status_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_block_status_sptr self, int which) -> float
        pc_output_buffers_full(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_block_status_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_block_status_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_block_status_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_block_status_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_block_status_sptr self) -> float"""
        return _baz_swig.baz_block_status_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_block_status_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_block_status_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_block_status_sptr self)"""
        return _baz_swig.baz_block_status_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_block_status_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_block_status_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_block_status_sptr self) -> int"""
        return _baz_swig.baz_block_status_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_block_status_sptr self) -> int"""
        return _baz_swig.baz_block_status_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_block_status_sptr self, int priority) -> int"""
        return _baz_swig.baz_block_status_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_block_status_sptr self) -> std::string"""
        return _baz_swig.baz_block_status_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_block_status_sptr self) -> std::string"""
        return _baz_swig.baz_block_status_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_block_status_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_block_status_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_block_status_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_block_status_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_block_status_sptr self) -> long"""
        return _baz_swig.baz_block_status_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_block_status_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_block_status_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_block_status_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_block_status_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_block_status_sptr self) -> std::string"""
        return _baz_swig.baz_block_status_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_block_status_sptr self, std::string name)"""
        return _baz_swig.baz_block_status_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_block_status_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_block_status_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_block_status_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_block_status_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_block_status_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_block_status_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_block_status_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_block_status_sptr_message_subscribers(self, which_port)

baz_block_status_sptr_swigregister = _baz_swig.baz_block_status_sptr_swigregister
baz_block_status_sptr_swigregister(baz_block_status_sptr)


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


def block_status(*args, **kwargs):
    """
    block_status(int size, unsigned long work_iterations, unsigned long samples_processed, msg_queue_sptr queue) -> baz_block_status_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_block_status.

    To avoid accidental use of raw pointers, baz_block_status's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (size, queue, work_iterations, samples_processed)
    """
    return _baz_swig.block_status(*args, **kwargs)
class baz_non_blocker_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_non_blocker)> class."""

    thisown = _swig_property(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<(baz_non_blocker)> self) -> baz_non_blocker_sptr
        __init__(boost::shared_ptr<(baz_non_blocker)> self, baz_non_blocker * p) -> baz_non_blocker_sptr
        """
        this = _baz_swig.new_baz_non_blocker_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_non_blocker_sptr self) -> baz_non_blocker *"""
        return _baz_swig.baz_non_blocker_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_non_blocker_sptr
    __del__ = lambda self: None

    def set_blocking(self, enable=True):
        """
        set_blocking(baz_non_blocker_sptr self, bool enable=True)



        Params: (enable)
        """
        return _baz_swig.baz_non_blocker_sptr_set_blocking(self, enable)


    def history(self):
        """history(baz_non_blocker_sptr self) -> unsigned int"""
        return _baz_swig.baz_non_blocker_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_non_blocker_sptr self, int which, int delay)
        declare_sample_delay(baz_non_blocker_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_non_blocker_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_non_blocker_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_non_blocker_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_non_blocker_sptr self) -> int"""
        return _baz_swig.baz_non_blocker_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_non_blocker_sptr self) -> double"""
        return _baz_swig.baz_non_blocker_sptr_relative_rate(self)


    def start(self):
        """start(baz_non_blocker_sptr self) -> bool"""
        return _baz_swig.baz_non_blocker_sptr_start(self)


    def stop(self):
        """stop(baz_non_blocker_sptr self) -> bool"""
        return _baz_swig.baz_non_blocker_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_non_blocker_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_non_blocker_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_non_blocker_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_non_blocker_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_non_blocker_sptr self) -> int"""
        return _baz_swig.baz_non_blocker_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_non_blocker_sptr self, int m)"""
        return _baz_swig.baz_non_blocker_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_non_blocker_sptr self)"""
        return _baz_swig.baz_non_blocker_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_non_blocker_sptr self) -> bool"""
        return _baz_swig.baz_non_blocker_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_non_blocker_sptr self, int m)"""
        return _baz_swig.baz_non_blocker_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_non_blocker_sptr self) -> int"""
        return _baz_swig.baz_non_blocker_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_non_blocker_sptr self, int i) -> long"""
        return _baz_swig.baz_non_blocker_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_non_blocker_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_non_blocker_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_non_blocker_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_non_blocker_sptr self, int i) -> long"""
        return _baz_swig.baz_non_blocker_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_non_blocker_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_non_blocker_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_non_blocker_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_non_blocker_sptr self, int which) -> float
        pc_input_buffers_full(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_non_blocker_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_non_blocker_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_non_blocker_sptr self, int which) -> float
        pc_output_buffers_full(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_non_blocker_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_non_blocker_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_non_blocker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_non_blocker_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_non_blocker_sptr self) -> float"""
        return _baz_swig.baz_non_blocker_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_non_blocker_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_non_blocker_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_non_blocker_sptr self)"""
        return _baz_swig.baz_non_blocker_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_non_blocker_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_non_blocker_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_non_blocker_sptr self) -> int"""
        return _baz_swig.baz_non_blocker_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_non_blocker_sptr self) -> int"""
        return _baz_swig.baz_non_blocker_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_non_blocker_sptr self, int priority) -> int"""
        return _baz_swig.baz_non_blocker_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_non_blocker_sptr self) -> std::string"""
        return _baz_swig.baz_non_blocker_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_non_blocker_sptr self) -> std::string"""
        return _baz_swig.baz_non_blocker_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_non_blocker_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_non_blocker_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_non_blocker_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_non_blocker_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_non_blocker_sptr self) -> long"""
        return _baz_swig.baz_non_blocker_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_non_blocker_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_non_blocker_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_non_blocker_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_non_blocker_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_non_blocker_sptr self) -> std::string"""
        return _baz_swig.baz_non_blocker_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_non_blocker_sptr self, std::string name)"""
        return _baz_swig.baz_non_blocker_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_non_blocker_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_non_blocker_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_non_blocker_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_non_blocker_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_non_blocker_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_non_blocker_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_non_blocker_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_non_blocker_sptr_message_subscribers(self, which_port)

baz_non_blocker_sptr_swigregister = _baz_swig.baz_non_blocker_sptr_swigregister
baz_non_blocker_sptr_swigregister(baz_non_blocker_sptr)


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


def non_blocker(item_size, blocking=False):
    """
    non_blocker(int item_size, bool blocking=False) -> baz_non_blocker_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_non_blocker.

    To avoid accidental use of raw pointers, baz_non_blocker's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, blocking)
    """
    return _baz_swig.non_blocker(item_size, blocking)
class baz_gate_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_gate)> class."""

    thisown = _swig_property(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<(baz_gate)> self) -> baz_gate_sptr
        __init__(boost::shared_ptr<(baz_gate)> self, baz_gate * p) -> baz_gate_sptr
        """
        this = _baz_swig.new_baz_gate_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_gate_sptr self) -> baz_gate *"""
        return _baz_swig.baz_gate_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_gate_sptr
    __del__ = lambda self: None

    def set_blocking(self, enable):
        """
        set_blocking(baz_gate_sptr self, bool enable)



        Params: (enable)
        """
        return _baz_swig.baz_gate_sptr_set_blocking(self, enable)


    def set_threshold(self, threshold):
        """
        set_threshold(baz_gate_sptr self, float threshold)



        Params: (threshold)
        """
        return _baz_swig.baz_gate_sptr_set_threshold(self, threshold)


    def set_trigger_length(self, trigger_length):
        """
        set_trigger_length(baz_gate_sptr self, int trigger_length)



        Params: (trigger_length)
        """
        return _baz_swig.baz_gate_sptr_set_trigger_length(self, trigger_length)


    def set_tagging(self, enable):
        """
        set_tagging(baz_gate_sptr self, bool enable)



        Params: (enable)
        """
        return _baz_swig.baz_gate_sptr_set_tagging(self, enable)


    def set_delay(self, delay):
        """
        set_delay(baz_gate_sptr self, double delay)



        Params: (delay)
        """
        return _baz_swig.baz_gate_sptr_set_delay(self, delay)


    def set_sample_rate(self, sample_rate):
        """
        set_sample_rate(baz_gate_sptr self, int sample_rate)



        Params: (sample_rate)
        """
        return _baz_swig.baz_gate_sptr_set_sample_rate(self, sample_rate)


    def set_no_delay(self, no_delay):
        """
        set_no_delay(baz_gate_sptr self, bool no_delay)



        Params: (no_delay)
        """
        return _baz_swig.baz_gate_sptr_set_no_delay(self, no_delay)


    def history(self):
        """history(baz_gate_sptr self) -> unsigned int"""
        return _baz_swig.baz_gate_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_gate_sptr self, int which, int delay)
        declare_sample_delay(baz_gate_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_gate_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_gate_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_gate_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_gate_sptr self) -> int"""
        return _baz_swig.baz_gate_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_gate_sptr self) -> double"""
        return _baz_swig.baz_gate_sptr_relative_rate(self)


    def start(self):
        """start(baz_gate_sptr self) -> bool"""
        return _baz_swig.baz_gate_sptr_start(self)


    def stop(self):
        """stop(baz_gate_sptr self) -> bool"""
        return _baz_swig.baz_gate_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_gate_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_gate_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_gate_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_gate_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_gate_sptr self) -> int"""
        return _baz_swig.baz_gate_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_gate_sptr self, int m)"""
        return _baz_swig.baz_gate_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_gate_sptr self)"""
        return _baz_swig.baz_gate_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_gate_sptr self) -> bool"""
        return _baz_swig.baz_gate_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_gate_sptr self, int m)"""
        return _baz_swig.baz_gate_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_gate_sptr self) -> int"""
        return _baz_swig.baz_gate_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_gate_sptr self, int i) -> long"""
        return _baz_swig.baz_gate_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_gate_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_gate_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_gate_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_gate_sptr self, int i) -> long"""
        return _baz_swig.baz_gate_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_gate_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_gate_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_gate_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_gate_sptr self, int which) -> float
        pc_input_buffers_full(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_gate_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_gate_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_gate_sptr self, int which) -> float
        pc_output_buffers_full(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_gate_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_gate_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_gate_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_gate_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_gate_sptr self) -> float"""
        return _baz_swig.baz_gate_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_gate_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_gate_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_gate_sptr self)"""
        return _baz_swig.baz_gate_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_gate_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_gate_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_gate_sptr self) -> int"""
        return _baz_swig.baz_gate_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_gate_sptr self) -> int"""
        return _baz_swig.baz_gate_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_gate_sptr self, int priority) -> int"""
        return _baz_swig.baz_gate_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_gate_sptr self) -> std::string"""
        return _baz_swig.baz_gate_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_gate_sptr self) -> std::string"""
        return _baz_swig.baz_gate_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_gate_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_gate_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_gate_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_gate_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_gate_sptr self) -> long"""
        return _baz_swig.baz_gate_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_gate_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_gate_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_gate_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_gate_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_gate_sptr self) -> std::string"""
        return _baz_swig.baz_gate_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_gate_sptr self, std::string name)"""
        return _baz_swig.baz_gate_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_gate_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_gate_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_gate_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_gate_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_gate_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_gate_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_gate_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_gate_sptr_message_subscribers(self, which_port)

baz_gate_sptr_swigregister = _baz_swig.baz_gate_sptr_swigregister
baz_gate_sptr_swigregister(baz_gate_sptr)


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


def gate(*args, **kwargs):
    """
    gate(int item_size, bool block=True, float threshold=1.0, int trigger_length=0, bool tag=False, double delay=0.0, int sample_rate=0, bool no_delay=False, bool verbose=True, bool retriggerable=False, std::string const & length_tag_name, bool complete_output=False, bool byte_trigger=False, std::string const & trigger_tag_name) -> baz_gate_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_gate.

    To avoid accidental use of raw pointers, baz_gate's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, block, threshold, trigger_length, tag, delay, sample_rate, no_delay, verbose, retriggerable, length_tag_name, complete_output, byte_trigger, trigger_tag_name)
    """
    return _baz_swig.gate(*args, **kwargs)
class usrp_acquire_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::usrp_acquire)> class."""

    thisown = _swig_property(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::baz::usrp_acquire)> self) -> usrp_acquire_sptr
        __init__(boost::shared_ptr<(gr::baz::usrp_acquire)> self, usrp_acquire p) -> usrp_acquire_sptr
        """
        this = _baz_swig.new_usrp_acquire_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(usrp_acquire_sptr self) -> usrp_acquire"""
        return _baz_swig.usrp_acquire_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_usrp_acquire_sptr
    __del__ = lambda self: None

    def make(self, dev, stream_args):
        """
        make(usrp_acquire_sptr self, ::uhd::usrp::multi_usrp::sptr dev, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



        Params: (dev, stream_args)
        """
        return _baz_swig.usrp_acquire_sptr_make(self, dev, stream_args)


    def make_from_source(self, source, stream_args):
        """
        make_from_source(usrp_acquire_sptr self, basic_block_sptr source, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



        Params: (source, stream_args)
        """
        return _baz_swig.usrp_acquire_sptr_make_from_source(self, source, stream_args)


    def finite_acquisition_v(self, nsamps, stream_now=True, delay=0.0, skip=0, timeout=1.0, loop=False):
        """
        finite_acquisition_v(usrp_acquire_sptr self, size_t const nsamps, bool stream_now=True, double delay=0.0, size_t skip=0, double timeout=1.0, bool loop=False) -> gr_vsize_t



        Params: (nsamps, stream_now, delay, skip, timeout, loop)
        """
        return _baz_swig.usrp_acquire_sptr_finite_acquisition_v(self, nsamps, stream_now, delay, skip, timeout, loop)


    def set_gpio_attr(self, bank, attr, value, mask, mboard=0):
        """
        set_gpio_attr(usrp_acquire_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask, size_t const mboard=0)



        Params: (bank, attr, value, mask, mboard)
        """
        return _baz_swig.usrp_acquire_sptr_set_gpio_attr(self, bank, attr, value, mask, mboard)


    def reset(self):
        """
        reset(usrp_acquire_sptr self)



        Params: ()
        """
        return _baz_swig.usrp_acquire_sptr_reset(self)


    def flush(self):
        """
        flush(usrp_acquire_sptr self) -> size_t



        Params: ()
        """
        return _baz_swig.usrp_acquire_sptr_flush(self)

usrp_acquire_sptr_swigregister = _baz_swig.usrp_acquire_sptr_swigregister
usrp_acquire_sptr_swigregister(usrp_acquire_sptr)

class usrp_acquire(object):
    """<+description+>"""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, dev, stream_args):
        """
        __init__(gr::baz::usrp_acquire self, ::uhd::usrp::multi_usrp::sptr dev, ::uhd::stream_args_t const & stream_args) -> usrp_acquire



        Params: (dev, stream_args)
        """
        this = _baz_swig.new_usrp_acquire(dev, stream_args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _baz_swig.delete_usrp_acquire
    __del__ = lambda self: None

    def make(dev, stream_args):
        """
        make(::uhd::usrp::multi_usrp::sptr dev, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



        Params: (dev, stream_args)
        """
        return _baz_swig.usrp_acquire_make(dev, stream_args)

    make = staticmethod(make)

    def make_from_source(source, stream_args):
        """
        make_from_source(basic_block_sptr source, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



        Params: (source, stream_args)
        """
        return _baz_swig.usrp_acquire_make_from_source(source, stream_args)

    make_from_source = staticmethod(make_from_source)

    def finite_acquisition_v(self, nsamps, stream_now=True, delay=0.0, skip=0, timeout=1.0, loop=False):
        """
        finite_acquisition_v(usrp_acquire self, size_t const nsamps, bool stream_now=True, double delay=0.0, size_t skip=0, double timeout=1.0, bool loop=False) -> gr_vsize_t



        Params: (nsamps, stream_now, delay, skip, timeout, loop)
        """
        return _baz_swig.usrp_acquire_finite_acquisition_v(self, nsamps, stream_now, delay, skip, timeout, loop)


    def set_gpio_attr(self, bank, attr, value, mask, mboard=0):
        """
        set_gpio_attr(usrp_acquire self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask, size_t const mboard=0)



        Params: (bank, attr, value, mask, mboard)
        """
        return _baz_swig.usrp_acquire_set_gpio_attr(self, bank, attr, value, mask, mboard)


    def reset(self):
        """
        reset(usrp_acquire self)



        Params: ()
        """
        return _baz_swig.usrp_acquire_reset(self)


    def flush(self):
        """
        flush(usrp_acquire self) -> size_t



        Params: ()
        """
        return _baz_swig.usrp_acquire_flush(self)

usrp_acquire_swigregister = _baz_swig.usrp_acquire_swigregister
usrp_acquire_swigregister(usrp_acquire)

def usrp_acquire_make(dev, stream_args):
    """
    usrp_acquire_make(::uhd::usrp::multi_usrp::sptr dev, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



    Params: (dev, stream_args)
    """
    return _baz_swig.usrp_acquire_make(dev, stream_args)

def usrp_acquire_make_from_source(source, stream_args):
    """
    usrp_acquire_make_from_source(basic_block_sptr source, ::uhd::stream_args_t const & stream_args) -> usrp_acquire_sptr



    Params: (source, stream_args)
    """
    return _baz_swig.usrp_acquire_make_from_source(source, stream_args)

class baz_hopper_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_hopper)> class."""

    thisown = _swig_property(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<(baz_hopper)> self) -> baz_hopper_sptr
        __init__(boost::shared_ptr<(baz_hopper)> self, baz_hopper * p) -> baz_hopper_sptr
        """
        this = _baz_swig.new_baz_hopper_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_hopper_sptr self) -> baz_hopper *"""
        return _baz_swig.baz_hopper_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_hopper_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_hopper_sptr self) -> unsigned int"""
        return _baz_swig.baz_hopper_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_hopper_sptr self, int which, int delay)
        declare_sample_delay(baz_hopper_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_hopper_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_hopper_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_hopper_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_hopper_sptr self) -> int"""
        return _baz_swig.baz_hopper_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_hopper_sptr self) -> double"""
        return _baz_swig.baz_hopper_sptr_relative_rate(self)


    def start(self):
        """start(baz_hopper_sptr self) -> bool"""
        return _baz_swig.baz_hopper_sptr_start(self)


    def stop(self):
        """stop(baz_hopper_sptr self) -> bool"""
        return _baz_swig.baz_hopper_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_hopper_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_hopper_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_hopper_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_hopper_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_hopper_sptr self) -> int"""
        return _baz_swig.baz_hopper_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_hopper_sptr self, int m)"""
        return _baz_swig.baz_hopper_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_hopper_sptr self)"""
        return _baz_swig.baz_hopper_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_hopper_sptr self) -> bool"""
        return _baz_swig.baz_hopper_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_hopper_sptr self, int m)"""
        return _baz_swig.baz_hopper_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_hopper_sptr self) -> int"""
        return _baz_swig.baz_hopper_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_hopper_sptr self, int i) -> long"""
        return _baz_swig.baz_hopper_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_hopper_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_hopper_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_hopper_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_hopper_sptr self, int i) -> long"""
        return _baz_swig.baz_hopper_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_hopper_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_hopper_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_hopper_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_hopper_sptr self, int which) -> float
        pc_input_buffers_full(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_hopper_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_hopper_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_hopper_sptr self, int which) -> float
        pc_output_buffers_full(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_hopper_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_hopper_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_hopper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_hopper_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_hopper_sptr self) -> float"""
        return _baz_swig.baz_hopper_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_hopper_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_hopper_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_hopper_sptr self)"""
        return _baz_swig.baz_hopper_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_hopper_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_hopper_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_hopper_sptr self) -> int"""
        return _baz_swig.baz_hopper_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_hopper_sptr self) -> int"""
        return _baz_swig.baz_hopper_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_hopper_sptr self, int priority) -> int"""
        return _baz_swig.baz_hopper_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_hopper_sptr self) -> std::string"""
        return _baz_swig.baz_hopper_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_hopper_sptr self) -> std::string"""
        return _baz_swig.baz_hopper_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_hopper_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_hopper_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_hopper_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_hopper_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_hopper_sptr self) -> long"""
        return _baz_swig.baz_hopper_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_hopper_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_hopper_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_hopper_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_hopper_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_hopper_sptr self) -> std::string"""
        return _baz_swig.baz_hopper_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_hopper_sptr self, std::string name)"""
        return _baz_swig.baz_hopper_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_hopper_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_hopper_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_hopper_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_hopper_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_hopper_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_hopper_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_hopper_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_hopper_sptr_message_subscribers(self, which_port)

baz_hopper_sptr_swigregister = _baz_swig.baz_hopper_sptr_swigregister
baz_hopper_sptr_swigregister(baz_hopper_sptr)


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


def hopper(item_size, sample_rate, chunk_length, drop_length, freqs, source, verbose=False):
    """
    hopper(size_t item_size, int sample_rate, int chunk_length, int drop_length, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > freqs, basic_block_sptr source, bool verbose=False) -> baz_hopper_sptr

    hop

    Params: (item_size, sample_rate, chunk_length, drop_length, freqs, source, verbose)
    """
    return _baz_swig.hopper(item_size, sample_rate, chunk_length, drop_length, freqs, source, verbose)
class baz_music_doa_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_music_doa)> class."""

    thisown = _swig_property(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<(baz_music_doa)> self) -> baz_music_doa_sptr
        __init__(boost::shared_ptr<(baz_music_doa)> self, baz_music_doa * p) -> baz_music_doa_sptr
        """
        this = _baz_swig.new_baz_music_doa_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_music_doa_sptr self) -> baz_music_doa *"""
        return _baz_swig.baz_music_doa_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_music_doa_sptr
    __del__ = lambda self: None

    def set_array_response(self, array_response):
        """
        set_array_response(baz_music_doa_sptr self, gr_vector_vector_complexf array_response)



        Params: (array_response)
        """
        return _baz_swig.baz_music_doa_sptr_set_array_response(self, array_response)


    def history(self):
        """history(baz_music_doa_sptr self) -> unsigned int"""
        return _baz_swig.baz_music_doa_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_music_doa_sptr self, int which, int delay)
        declare_sample_delay(baz_music_doa_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_music_doa_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_music_doa_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_music_doa_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_music_doa_sptr self) -> int"""
        return _baz_swig.baz_music_doa_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_music_doa_sptr self) -> double"""
        return _baz_swig.baz_music_doa_sptr_relative_rate(self)


    def start(self):
        """start(baz_music_doa_sptr self) -> bool"""
        return _baz_swig.baz_music_doa_sptr_start(self)


    def stop(self):
        """stop(baz_music_doa_sptr self) -> bool"""
        return _baz_swig.baz_music_doa_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_music_doa_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_music_doa_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_music_doa_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_music_doa_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_music_doa_sptr self) -> int"""
        return _baz_swig.baz_music_doa_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_music_doa_sptr self, int m)"""
        return _baz_swig.baz_music_doa_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_music_doa_sptr self)"""
        return _baz_swig.baz_music_doa_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_music_doa_sptr self) -> bool"""
        return _baz_swig.baz_music_doa_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_music_doa_sptr self, int m)"""
        return _baz_swig.baz_music_doa_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_music_doa_sptr self) -> int"""
        return _baz_swig.baz_music_doa_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_music_doa_sptr self, int i) -> long"""
        return _baz_swig.baz_music_doa_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_music_doa_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_music_doa_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_music_doa_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_music_doa_sptr self, int i) -> long"""
        return _baz_swig.baz_music_doa_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_music_doa_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_music_doa_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_music_doa_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_music_doa_sptr self, int which) -> float
        pc_input_buffers_full(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_music_doa_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_music_doa_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_music_doa_sptr self, int which) -> float
        pc_output_buffers_full(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_music_doa_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_music_doa_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_music_doa_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_music_doa_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_music_doa_sptr self) -> float"""
        return _baz_swig.baz_music_doa_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_music_doa_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_music_doa_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_music_doa_sptr self)"""
        return _baz_swig.baz_music_doa_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_music_doa_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_music_doa_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_music_doa_sptr self) -> int"""
        return _baz_swig.baz_music_doa_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_music_doa_sptr self) -> int"""
        return _baz_swig.baz_music_doa_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_music_doa_sptr self, int priority) -> int"""
        return _baz_swig.baz_music_doa_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_music_doa_sptr self) -> std::string"""
        return _baz_swig.baz_music_doa_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_music_doa_sptr self) -> std::string"""
        return _baz_swig.baz_music_doa_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_music_doa_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_music_doa_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_music_doa_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_music_doa_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_music_doa_sptr self) -> long"""
        return _baz_swig.baz_music_doa_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_music_doa_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_music_doa_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_music_doa_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_music_doa_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_music_doa_sptr self) -> std::string"""
        return _baz_swig.baz_music_doa_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_music_doa_sptr self, std::string name)"""
        return _baz_swig.baz_music_doa_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_music_doa_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_music_doa_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_music_doa_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_music_doa_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_music_doa_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_music_doa_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_music_doa_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_music_doa_sptr_message_subscribers(self, which_port)

baz_music_doa_sptr_swigregister = _baz_swig.baz_music_doa_sptr_swigregister
baz_music_doa_sptr_swigregister(baz_music_doa_sptr)


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


def music_doa(m, n, nsamples, array_response, resolution):
    """
    music_doa(unsigned int m, unsigned int n, unsigned int nsamples, gr_vector_vector_complexf array_response, unsigned int resolution) -> baz_music_doa_sptr



    Params: (m, n, nsamples, array_response, resolution)
    """
    return _baz_swig.music_doa(m, n, nsamples, array_response, resolution)
class baz_acars_decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_acars_decoder)> class."""

    thisown = _swig_property(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<(baz_acars_decoder)> self) -> baz_acars_decoder_sptr
        __init__(boost::shared_ptr<(baz_acars_decoder)> self, baz_acars_decoder * p) -> baz_acars_decoder_sptr
        """
        this = _baz_swig.new_baz_acars_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_acars_decoder_sptr self) -> baz_acars_decoder *"""
        return _baz_swig.baz_acars_decoder_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_acars_decoder_sptr
    __del__ = lambda self: None

    def set_preamble_threshold(self, threshold):
        """
        set_preamble_threshold(baz_acars_decoder_sptr self, int threshold)



        Params: (threshold)
        """
        return _baz_swig.baz_acars_decoder_sptr_set_preamble_threshold(self, threshold)


    def set_frequency(self, frequency):
        """
        set_frequency(baz_acars_decoder_sptr self, float frequency)



        Params: (frequency)
        """
        return _baz_swig.baz_acars_decoder_sptr_set_frequency(self, frequency)


    def set_station_name(self, station_name):
        """
        set_station_name(baz_acars_decoder_sptr self, char const * station_name)



        Params: (station_name)
        """
        return _baz_swig.baz_acars_decoder_sptr_set_station_name(self, station_name)


    def preamble_threshold(self):
        """
        preamble_threshold(baz_acars_decoder_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.baz_acars_decoder_sptr_preamble_threshold(self)


    def frequency(self):
        """
        frequency(baz_acars_decoder_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_acars_decoder_sptr_frequency(self)


    def station_name(self):
        """
        station_name(baz_acars_decoder_sptr self) -> char const *



        Params: (NONE)
        """
        return _baz_swig.baz_acars_decoder_sptr_station_name(self)


    def history(self):
        """history(baz_acars_decoder_sptr self) -> unsigned int"""
        return _baz_swig.baz_acars_decoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_acars_decoder_sptr self, int which, int delay)
        declare_sample_delay(baz_acars_decoder_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_acars_decoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_acars_decoder_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_acars_decoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_acars_decoder_sptr self) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_acars_decoder_sptr self) -> double"""
        return _baz_swig.baz_acars_decoder_sptr_relative_rate(self)


    def start(self):
        """start(baz_acars_decoder_sptr self) -> bool"""
        return _baz_swig.baz_acars_decoder_sptr_start(self)


    def stop(self):
        """stop(baz_acars_decoder_sptr self) -> bool"""
        return _baz_swig.baz_acars_decoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_acars_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_acars_decoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_acars_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_acars_decoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_acars_decoder_sptr self) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_acars_decoder_sptr self, int m)"""
        return _baz_swig.baz_acars_decoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_acars_decoder_sptr self)"""
        return _baz_swig.baz_acars_decoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_acars_decoder_sptr self) -> bool"""
        return _baz_swig.baz_acars_decoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_acars_decoder_sptr self, int m)"""
        return _baz_swig.baz_acars_decoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_acars_decoder_sptr self) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_acars_decoder_sptr self, int i) -> long"""
        return _baz_swig.baz_acars_decoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_acars_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_acars_decoder_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_acars_decoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_acars_decoder_sptr self, int i) -> long"""
        return _baz_swig.baz_acars_decoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_acars_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_acars_decoder_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_acars_decoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_acars_decoder_sptr self, int which) -> float
        pc_input_buffers_full(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_acars_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_acars_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_acars_decoder_sptr self, int which) -> float
        pc_output_buffers_full(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_acars_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_acars_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_acars_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_acars_decoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_acars_decoder_sptr self) -> float"""
        return _baz_swig.baz_acars_decoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_acars_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_acars_decoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_acars_decoder_sptr self)"""
        return _baz_swig.baz_acars_decoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_acars_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_acars_decoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_acars_decoder_sptr self) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_acars_decoder_sptr self) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_acars_decoder_sptr self, int priority) -> int"""
        return _baz_swig.baz_acars_decoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_acars_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_acars_decoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_acars_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_acars_decoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_acars_decoder_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_acars_decoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_acars_decoder_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_acars_decoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_acars_decoder_sptr self) -> long"""
        return _baz_swig.baz_acars_decoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_acars_decoder_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_acars_decoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_acars_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_acars_decoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_acars_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_acars_decoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_acars_decoder_sptr self, std::string name)"""
        return _baz_swig.baz_acars_decoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_acars_decoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_acars_decoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_acars_decoder_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_acars_decoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_acars_decoder_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_acars_decoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_acars_decoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_acars_decoder_sptr_message_subscribers(self, which_port)

baz_acars_decoder_sptr_swigregister = _baz_swig.baz_acars_decoder_sptr_swigregister
baz_acars_decoder_sptr_swigregister(baz_acars_decoder_sptr)


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


def acars_decoder(msgq):
    """
    acars_decoder(msg_queue_sptr msgq) -> baz_acars_decoder_sptr

    acars a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_acars_decoder.

    To avoid accidental use of raw pointers, baz_acars_decoder's constructor is private. baz_acars_decoder is the public interface for creating new instances.

    Params: (msgq)
    """
    return _baz_swig.acars_decoder(msgq)
class baz_tag_to_msg_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_tag_to_msg)> class."""

    thisown = _swig_property(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<(baz_tag_to_msg)> self) -> baz_tag_to_msg_sptr
        __init__(boost::shared_ptr<(baz_tag_to_msg)> self, baz_tag_to_msg * p) -> baz_tag_to_msg_sptr
        """
        this = _baz_swig.new_baz_tag_to_msg_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_tag_to_msg_sptr self) -> baz_tag_to_msg *"""
        return _baz_swig.baz_tag_to_msg_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_tag_to_msg_sptr
    __del__ = lambda self: None

    def set_msgq(self, msgq):
        """
        set_msgq(baz_tag_to_msg_sptr self, msg_queue_sptr msgq)



        Params: (msgq)
        """
        return _baz_swig.baz_tag_to_msg_sptr_set_msgq(self, msgq)


    def set_appended_string(self, append):
        """
        set_appended_string(baz_tag_to_msg_sptr self, char const * append)



        Params: (append)
        """
        return _baz_swig.baz_tag_to_msg_sptr_set_appended_string(self, append)


    def history(self):
        """history(baz_tag_to_msg_sptr self) -> unsigned int"""
        return _baz_swig.baz_tag_to_msg_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_tag_to_msg_sptr self, int which, int delay)
        declare_sample_delay(baz_tag_to_msg_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_tag_to_msg_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_tag_to_msg_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_tag_to_msg_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_tag_to_msg_sptr self) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_tag_to_msg_sptr self) -> double"""
        return _baz_swig.baz_tag_to_msg_sptr_relative_rate(self)


    def start(self):
        """start(baz_tag_to_msg_sptr self) -> bool"""
        return _baz_swig.baz_tag_to_msg_sptr_start(self)


    def stop(self):
        """stop(baz_tag_to_msg_sptr self) -> bool"""
        return _baz_swig.baz_tag_to_msg_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_tag_to_msg_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_tag_to_msg_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_tag_to_msg_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_tag_to_msg_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_tag_to_msg_sptr self) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_tag_to_msg_sptr self, int m)"""
        return _baz_swig.baz_tag_to_msg_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_tag_to_msg_sptr self)"""
        return _baz_swig.baz_tag_to_msg_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_tag_to_msg_sptr self) -> bool"""
        return _baz_swig.baz_tag_to_msg_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_tag_to_msg_sptr self, int m)"""
        return _baz_swig.baz_tag_to_msg_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_tag_to_msg_sptr self) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_tag_to_msg_sptr self, int i) -> long"""
        return _baz_swig.baz_tag_to_msg_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_tag_to_msg_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_tag_to_msg_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_tag_to_msg_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_tag_to_msg_sptr self, int i) -> long"""
        return _baz_swig.baz_tag_to_msg_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_tag_to_msg_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_tag_to_msg_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_tag_to_msg_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_tag_to_msg_sptr self, int which) -> float
        pc_input_buffers_full(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_tag_to_msg_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_tag_to_msg_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_tag_to_msg_sptr self, int which) -> float
        pc_output_buffers_full(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_tag_to_msg_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_tag_to_msg_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_tag_to_msg_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tag_to_msg_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_tag_to_msg_sptr self) -> float"""
        return _baz_swig.baz_tag_to_msg_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_tag_to_msg_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_tag_to_msg_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_tag_to_msg_sptr self)"""
        return _baz_swig.baz_tag_to_msg_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_tag_to_msg_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_tag_to_msg_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_tag_to_msg_sptr self) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_tag_to_msg_sptr self) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_tag_to_msg_sptr self, int priority) -> int"""
        return _baz_swig.baz_tag_to_msg_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_tag_to_msg_sptr self) -> std::string"""
        return _baz_swig.baz_tag_to_msg_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_tag_to_msg_sptr self) -> std::string"""
        return _baz_swig.baz_tag_to_msg_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_tag_to_msg_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tag_to_msg_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_tag_to_msg_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tag_to_msg_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_tag_to_msg_sptr self) -> long"""
        return _baz_swig.baz_tag_to_msg_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_tag_to_msg_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_tag_to_msg_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_tag_to_msg_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_tag_to_msg_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_tag_to_msg_sptr self) -> std::string"""
        return _baz_swig.baz_tag_to_msg_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_tag_to_msg_sptr self, std::string name)"""
        return _baz_swig.baz_tag_to_msg_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_tag_to_msg_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_tag_to_msg_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_tag_to_msg_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tag_to_msg_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_tag_to_msg_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tag_to_msg_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_tag_to_msg_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_tag_to_msg_sptr_message_subscribers(self, which_port)

baz_tag_to_msg_sptr_swigregister = _baz_swig.baz_tag_to_msg_sptr_swigregister
baz_tag_to_msg_sptr_swigregister(baz_tag_to_msg_sptr)


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


def tag_to_msg(item_size, msgq, append=None):
    """
    tag_to_msg(int item_size, msg_queue_sptr msgq, char const * append=None) -> baz_tag_to_msg_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_tag_to_msg.

    To avoid accidental use of raw pointers, baz_tag_to_msg's constructor is private. baz_make_tag_to_msg is the public interface for creating new instances.

    Params: (item_size, msgq, append)
    """
    return _baz_swig.tag_to_msg(item_size, msgq, append)
class baz_time_keeper_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_time_keeper)> class."""

    thisown = _swig_property(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<(baz_time_keeper)> self) -> baz_time_keeper_sptr
        __init__(boost::shared_ptr<(baz_time_keeper)> self, baz_time_keeper * p) -> baz_time_keeper_sptr
        """
        this = _baz_swig.new_baz_time_keeper_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_time_keeper_sptr self) -> baz_time_keeper *"""
        return _baz_swig.baz_time_keeper_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_time_keeper_sptr
    __del__ = lambda self: None

    def time(self, relative=False):
        """
        time(baz_time_keeper_sptr self, bool relative=False) -> double



        Params: (relative)
        """
        return _baz_swig.baz_time_keeper_sptr_time(self, relative)


    def ignore_next(self, ignore=True):
        """
        ignore_next(baz_time_keeper_sptr self, bool ignore=True)



        Params: (ignore)
        """
        return _baz_swig.baz_time_keeper_sptr_ignore_next(self, ignore)


    def update_count(self):
        """
        update_count(baz_time_keeper_sptr self) -> int



        Params: ()
        """
        return _baz_swig.baz_time_keeper_sptr_update_count(self)


    def history(self):
        """history(baz_time_keeper_sptr self) -> unsigned int"""
        return _baz_swig.baz_time_keeper_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_time_keeper_sptr self, int which, int delay)
        declare_sample_delay(baz_time_keeper_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_time_keeper_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_time_keeper_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_time_keeper_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_time_keeper_sptr self) -> int"""
        return _baz_swig.baz_time_keeper_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_time_keeper_sptr self) -> double"""
        return _baz_swig.baz_time_keeper_sptr_relative_rate(self)


    def start(self):
        """start(baz_time_keeper_sptr self) -> bool"""
        return _baz_swig.baz_time_keeper_sptr_start(self)


    def stop(self):
        """stop(baz_time_keeper_sptr self) -> bool"""
        return _baz_swig.baz_time_keeper_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_time_keeper_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_time_keeper_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_time_keeper_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_time_keeper_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_time_keeper_sptr self) -> int"""
        return _baz_swig.baz_time_keeper_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_time_keeper_sptr self, int m)"""
        return _baz_swig.baz_time_keeper_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_time_keeper_sptr self)"""
        return _baz_swig.baz_time_keeper_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_time_keeper_sptr self) -> bool"""
        return _baz_swig.baz_time_keeper_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_time_keeper_sptr self, int m)"""
        return _baz_swig.baz_time_keeper_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_time_keeper_sptr self) -> int"""
        return _baz_swig.baz_time_keeper_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_time_keeper_sptr self, int i) -> long"""
        return _baz_swig.baz_time_keeper_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_time_keeper_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_time_keeper_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_time_keeper_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_time_keeper_sptr self, int i) -> long"""
        return _baz_swig.baz_time_keeper_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_time_keeper_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_time_keeper_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_time_keeper_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_time_keeper_sptr self, int which) -> float
        pc_input_buffers_full(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_time_keeper_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_time_keeper_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_time_keeper_sptr self, int which) -> float
        pc_output_buffers_full(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_time_keeper_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_time_keeper_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_time_keeper_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_time_keeper_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_time_keeper_sptr self) -> float"""
        return _baz_swig.baz_time_keeper_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_time_keeper_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_time_keeper_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_time_keeper_sptr self)"""
        return _baz_swig.baz_time_keeper_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_time_keeper_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_time_keeper_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_time_keeper_sptr self) -> int"""
        return _baz_swig.baz_time_keeper_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_time_keeper_sptr self) -> int"""
        return _baz_swig.baz_time_keeper_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_time_keeper_sptr self, int priority) -> int"""
        return _baz_swig.baz_time_keeper_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_time_keeper_sptr self) -> std::string"""
        return _baz_swig.baz_time_keeper_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_time_keeper_sptr self) -> std::string"""
        return _baz_swig.baz_time_keeper_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_time_keeper_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_time_keeper_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_time_keeper_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_time_keeper_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_time_keeper_sptr self) -> long"""
        return _baz_swig.baz_time_keeper_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_time_keeper_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_time_keeper_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_time_keeper_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_time_keeper_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_time_keeper_sptr self) -> std::string"""
        return _baz_swig.baz_time_keeper_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_time_keeper_sptr self, std::string name)"""
        return _baz_swig.baz_time_keeper_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_time_keeper_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_time_keeper_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_time_keeper_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_time_keeper_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_time_keeper_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_time_keeper_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_time_keeper_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_time_keeper_sptr_message_subscribers(self, which_port)

baz_time_keeper_sptr_swigregister = _baz_swig.baz_time_keeper_sptr_swigregister
baz_time_keeper_sptr_swigregister(baz_time_keeper_sptr)


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


def time_keeper(item_size, sample_rate):
    """
    time_keeper(int item_size, float sample_rate) -> baz_time_keeper_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_time_keeper.

    To avoid accidental use of raw pointers, baz_time_keeper's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, sample_rate)
    """
    return _baz_swig.time_keeper(item_size, sample_rate)
class map_string_string(object):
    """
    Apply  element-wise to the elements of list and returns a list of the results, in order.

    must be a list. The dynamic order in which  is applied to the elements of  is unspecified.
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(map_string_string self) -> SwigPyIterator"""
        return _baz_swig.map_string_string_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(map_string_string self) -> bool"""
        return _baz_swig.map_string_string___nonzero__(self)


    def __bool__(self):
        """__bool__(map_string_string self) -> bool"""
        return _baz_swig.map_string_string___bool__(self)


    def __len__(self):
        """__len__(map_string_string self) -> std::map< std::string,std::string >::size_type"""
        return _baz_swig.map_string_string___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _baz_swig.map_string_string___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key)"""
        return _baz_swig.map_string_string___delitem__(self, key)


    def has_key(self, key):
        """has_key(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _baz_swig.map_string_string_has_key(self, key)


    def keys(self):
        """keys(map_string_string self) -> PyObject *"""
        return _baz_swig.map_string_string_keys(self)


    def values(self):
        """values(map_string_string self) -> PyObject *"""
        return _baz_swig.map_string_string_values(self)


    def items(self):
        """items(map_string_string self) -> PyObject *"""
        return _baz_swig.map_string_string_items(self)


    def __contains__(self, key):
        """__contains__(map_string_string self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _baz_swig.map_string_string___contains__(self, key)


    def key_iterator(self):
        """key_iterator(map_string_string self) -> SwigPyIterator"""
        return _baz_swig.map_string_string_key_iterator(self)


    def value_iterator(self):
        """value_iterator(map_string_string self) -> SwigPyIterator"""
        return _baz_swig.map_string_string_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(map_string_string self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _baz_swig.map_string_string___setitem__(self, *args)


    def asdict(self):
        """asdict(map_string_string self) -> PyObject *"""
        return _baz_swig.map_string_string_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,std::string)> self, std::less< std::string > const & arg2) -> map_string_string
        __init__(std::map<(std::string,std::string)> self) -> map_string_string
        __init__(std::map<(std::string,std::string)> self, map_string_string arg2) -> map_string_string

        Apply  element-wise to the elements of list and returns a list of the results, in order.

        must be a list. The dynamic order in which  is applied to the elements of  is unspecified.
        """
        this = _baz_swig.new_map_string_string(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(map_string_string self) -> bool"""
        return _baz_swig.map_string_string_empty(self)


    def size(self):
        """size(map_string_string self) -> std::map< std::string,std::string >::size_type"""
        return _baz_swig.map_string_string_size(self)


    def swap(self, v):
        """swap(map_string_string self, map_string_string v)"""
        return _baz_swig.map_string_string_swap(self, v)


    def begin(self):
        """begin(map_string_string self) -> std::map< std::string,std::string >::iterator"""
        return _baz_swig.map_string_string_begin(self)


    def end(self):
        """end(map_string_string self) -> std::map< std::string,std::string >::iterator"""
        return _baz_swig.map_string_string_end(self)


    def rbegin(self):
        """rbegin(map_string_string self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _baz_swig.map_string_string_rbegin(self)


    def rend(self):
        """rend(map_string_string self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _baz_swig.map_string_string_rend(self)


    def clear(self):
        """clear(map_string_string self)"""
        return _baz_swig.map_string_string_clear(self)


    def get_allocator(self):
        """get_allocator(map_string_string self) -> std::map< std::string,std::string >::allocator_type"""
        return _baz_swig.map_string_string_get_allocator(self)


    def count(self, x):
        """count(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _baz_swig.map_string_string_count(self, x)


    def erase(self, *args):
        """
        erase(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(map_string_string self, std::map< std::string,std::string >::iterator position)
        erase(map_string_string self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _baz_swig.map_string_string_erase(self, *args)


    def find(self, x):
        """find(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _baz_swig.map_string_string_find(self, x)


    def lower_bound(self, x):
        """lower_bound(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _baz_swig.map_string_string_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(map_string_string self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _baz_swig.map_string_string_upper_bound(self, x)

    __swig_destroy__ = _baz_swig.delete_map_string_string
    __del__ = lambda self: None
map_string_string_swigregister = _baz_swig.map_string_string_swigregister
map_string_string_swigregister(map_string_string)

class vector_string(object):
    """Proxy of C++ std::vector<(std::string)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vector_string self) -> SwigPyIterator"""
        return _baz_swig.vector_string_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vector_string self) -> bool"""
        return _baz_swig.vector_string___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_string self) -> bool"""
        return _baz_swig.vector_string___bool__(self)


    def __len__(self):
        """__len__(vector_string self) -> std::vector< std::string >::size_type"""
        return _baz_swig.vector_string___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> std::vector< std::string,std::allocator< std::string > > *"""
        return _baz_swig.vector_string___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, std::vector< std::string,std::allocator< std::string > > const & v)
        """
        return _baz_swig.vector_string___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _baz_swig.vector_string___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_string self, std::vector< std::string >::difference_type i)
        __delitem__(vector_string self, PySliceObject * slice)
        """
        return _baz_swig.vector_string___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_string self, PySliceObject * slice) -> std::vector< std::string,std::allocator< std::string > >
        __getitem__(vector_string self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _baz_swig.vector_string___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_string self, PySliceObject * slice, std::vector< std::string,std::allocator< std::string > > const & v)
        __setitem__(vector_string self, PySliceObject * slice)
        __setitem__(vector_string self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _baz_swig.vector_string___setitem__(self, *args)


    def pop(self):
        """pop(vector_string self) -> std::vector< std::string >::value_type"""
        return _baz_swig.vector_string_pop(self)


    def append(self, x):
        """append(vector_string self, std::vector< std::string >::value_type const & x)"""
        return _baz_swig.vector_string_append(self, x)


    def empty(self):
        """empty(vector_string self) -> bool"""
        return _baz_swig.vector_string_empty(self)


    def size(self):
        """size(vector_string self) -> std::vector< std::string >::size_type"""
        return _baz_swig.vector_string_size(self)


    def swap(self, v):
        """swap(vector_string self, std::vector< std::string > & v)"""
        return _baz_swig.vector_string_swap(self, v)


    def begin(self):
        """begin(vector_string self) -> std::vector< std::string >::iterator"""
        return _baz_swig.vector_string_begin(self)


    def end(self):
        """end(vector_string self) -> std::vector< std::string >::iterator"""
        return _baz_swig.vector_string_end(self)


    def rbegin(self):
        """rbegin(vector_string self) -> std::vector< std::string >::reverse_iterator"""
        return _baz_swig.vector_string_rbegin(self)


    def rend(self):
        """rend(vector_string self) -> std::vector< std::string >::reverse_iterator"""
        return _baz_swig.vector_string_rend(self)


    def clear(self):
        """clear(vector_string self)"""
        return _baz_swig.vector_string_clear(self)


    def get_allocator(self):
        """get_allocator(vector_string self) -> std::vector< std::string >::allocator_type"""
        return _baz_swig.vector_string_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_string self)"""
        return _baz_swig.vector_string_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_string self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(vector_string self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _baz_swig.vector_string_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> vector_string
        __init__(std::vector<(std::string)> self, std::vector< std::string > const & arg2) -> vector_string
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> vector_string
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string
        """
        this = _baz_swig.new_vector_string(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_string self, std::vector< std::string >::value_type const & x)"""
        return _baz_swig.vector_string_push_back(self, x)


    def front(self):
        """front(vector_string self) -> std::vector< std::string >::value_type const &"""
        return _baz_swig.vector_string_front(self)


    def back(self):
        """back(vector_string self) -> std::vector< std::string >::value_type const &"""
        return _baz_swig.vector_string_back(self)


    def assign(self, n, x):
        """assign(vector_string self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _baz_swig.vector_string_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_string self, std::vector< std::string >::size_type new_size)
        resize(vector_string self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _baz_swig.vector_string_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(vector_string self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _baz_swig.vector_string_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_string self, std::vector< std::string >::size_type n)"""
        return _baz_swig.vector_string_reserve(self, n)


    def capacity(self):
        """capacity(vector_string self) -> std::vector< std::string >::size_type"""
        return _baz_swig.vector_string_capacity(self)

    __swig_destroy__ = _baz_swig.delete_vector_string
    __del__ = lambda self: None
vector_string_swigregister = _baz_swig.vector_string_swigregister
vector_string_swigregister(vector_string)


def _baz_burster_config_xform_types(k, v):
	if k in ['trigger_tags', 'length_tags']:
		return vector_string(v)
	if k in ['eob_tags']:
		return map_string_string(v)
	return v

class baz_burster_config(object):
    """Proxy of C++ baz_burster_config_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    sample_rate = _swig_property(_baz_swig.baz_burster_config_sample_rate_get, _baz_swig.baz_burster_config_sample_rate_set)
    item_size = _swig_property(_baz_swig.baz_burster_config_item_size_get, _baz_swig.baz_burster_config_item_size_set)
    burst_length = _swig_property(_baz_swig.baz_burster_config_burst_length_get, _baz_swig.baz_burster_config_burst_length_set)
    interval = _swig_property(_baz_swig.baz_burster_config_interval_get, _baz_swig.baz_burster_config_interval_set)
    sample_interval = _swig_property(_baz_swig.baz_burster_config_sample_interval_get, _baz_swig.baz_burster_config_sample_interval_set)
    relative_time = _swig_property(_baz_swig.baz_burster_config_relative_time_get, _baz_swig.baz_burster_config_relative_time_set)
    drop_current = _swig_property(_baz_swig.baz_burster_config_drop_current_get, _baz_swig.baz_burster_config_drop_current_set)
    use_host_time = _swig_property(_baz_swig.baz_burster_config_use_host_time_get, _baz_swig.baz_burster_config_use_host_time_set)
    read_time_tag = _swig_property(_baz_swig.baz_burster_config_read_time_tag_get, _baz_swig.baz_burster_config_read_time_tag_set)
    output_messages = _swig_property(_baz_swig.baz_burster_config_output_messages_get, _baz_swig.baz_burster_config_output_messages_set)
    msgq = _swig_property(_baz_swig.baz_burster_config_msgq_get, _baz_swig.baz_burster_config_msgq_set)
    output_stream = _swig_property(_baz_swig.baz_burster_config_output_stream_get, _baz_swig.baz_burster_config_output_stream_set)
    trigger_on_tags = _swig_property(_baz_swig.baz_burster_config_trigger_on_tags_get, _baz_swig.baz_burster_config_trigger_on_tags_set)
    use_tag_lengths = _swig_property(_baz_swig.baz_burster_config_use_tag_lengths_get, _baz_swig.baz_burster_config_use_tag_lengths_set)
    trigger_tags = _swig_property(_baz_swig.baz_burster_config_trigger_tags_get, _baz_swig.baz_burster_config_trigger_tags_set)
    length_tags = _swig_property(_baz_swig.baz_burster_config_length_tags_get, _baz_swig.baz_burster_config_length_tags_set)
    eob_tags = _swig_property(_baz_swig.baz_burster_config_eob_tags_get, _baz_swig.baz_burster_config_eob_tags_set)

    def __init__(self):
        """__init__(baz_burster_config_t self) -> baz_burster_config"""
        this = _baz_swig.new_baz_burster_config()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _baz_swig.delete_baz_burster_config
    __del__ = lambda self: None
baz_burster_config_swigregister = _baz_swig.baz_burster_config_swigregister
baz_burster_config_swigregister(baz_burster_config)


class burster_config(baz_burster_config):
	def __init__(self, *args, **kwds):
		baz_burster_config.__init__(self)
		for k in kwds.keys():
			if hasattr(self, k):
				setattr(self, k, _baz_burster_config_xform_types(k, kwds[k]))

class baz_burster_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_burster)> class."""

    thisown = _swig_property(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<(baz_burster)> self) -> baz_burster_sptr
        __init__(boost::shared_ptr<(baz_burster)> self, baz_burster * p) -> baz_burster_sptr
        """
        this = _baz_swig.new_baz_burster_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_burster_sptr self) -> baz_burster *"""
        return _baz_swig.baz_burster_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_burster_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_burster_sptr self) -> unsigned int"""
        return _baz_swig.baz_burster_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_burster_sptr self, int which, int delay)
        declare_sample_delay(baz_burster_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_burster_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_burster_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_burster_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_burster_sptr self) -> int"""
        return _baz_swig.baz_burster_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_burster_sptr self) -> double"""
        return _baz_swig.baz_burster_sptr_relative_rate(self)


    def start(self):
        """start(baz_burster_sptr self) -> bool"""
        return _baz_swig.baz_burster_sptr_start(self)


    def stop(self):
        """stop(baz_burster_sptr self) -> bool"""
        return _baz_swig.baz_burster_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_burster_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_burster_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_burster_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_burster_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_burster_sptr self) -> int"""
        return _baz_swig.baz_burster_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_burster_sptr self, int m)"""
        return _baz_swig.baz_burster_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_burster_sptr self)"""
        return _baz_swig.baz_burster_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_burster_sptr self) -> bool"""
        return _baz_swig.baz_burster_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_burster_sptr self, int m)"""
        return _baz_swig.baz_burster_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_burster_sptr self) -> int"""
        return _baz_swig.baz_burster_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_burster_sptr self, int i) -> long"""
        return _baz_swig.baz_burster_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_burster_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_burster_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_burster_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_burster_sptr self, int i) -> long"""
        return _baz_swig.baz_burster_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_burster_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_burster_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_burster_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_burster_sptr self, int which) -> float
        pc_input_buffers_full(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_burster_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_burster_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_burster_sptr self, int which) -> float
        pc_output_buffers_full(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_burster_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_burster_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_burster_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burster_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_burster_sptr self) -> float"""
        return _baz_swig.baz_burster_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_burster_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_burster_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_burster_sptr self)"""
        return _baz_swig.baz_burster_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_burster_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_burster_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_burster_sptr self) -> int"""
        return _baz_swig.baz_burster_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_burster_sptr self) -> int"""
        return _baz_swig.baz_burster_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_burster_sptr self, int priority) -> int"""
        return _baz_swig.baz_burster_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_burster_sptr self) -> std::string"""
        return _baz_swig.baz_burster_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_burster_sptr self) -> std::string"""
        return _baz_swig.baz_burster_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_burster_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_burster_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_burster_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_burster_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_burster_sptr self) -> long"""
        return _baz_swig.baz_burster_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_burster_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_burster_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_burster_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_burster_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_burster_sptr self) -> std::string"""
        return _baz_swig.baz_burster_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_burster_sptr self, std::string name)"""
        return _baz_swig.baz_burster_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_burster_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_burster_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_burster_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_burster_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_burster_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_burster_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_burster_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_burster_sptr_message_subscribers(self, which_port)

baz_burster_sptr_swigregister = _baz_swig.baz_burster_sptr_swigregister
baz_burster_sptr_swigregister(baz_burster_sptr)


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


def burster(config):
    """
    burster(baz_burster_config config) -> baz_burster_sptr

    burster a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_burster.

    To avoid accidental use of raw pointers, baz_burster's constructor is private. baz_make_burster is the public interface for creating new instances.

    Params: (config)
    """
    return _baz_swig.burster(config)
class baz_radar_detector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_radar_detector)> class."""

    thisown = _swig_property(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<(baz_radar_detector)> self) -> baz_radar_detector_sptr
        __init__(boost::shared_ptr<(baz_radar_detector)> self, baz_radar_detector * p) -> baz_radar_detector_sptr
        """
        this = _baz_swig.new_baz_radar_detector_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_radar_detector_sptr self) -> baz_radar_detector *"""
        return _baz_swig.baz_radar_detector_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_radar_detector_sptr
    __del__ = lambda self: None

    def set_base_level(self, level):
        """
        set_base_level(baz_radar_detector_sptr self, float level)



        Params: (level)
        """
        return _baz_swig.baz_radar_detector_sptr_set_base_level(self, level)


    def set_threshold(self, threshold):
        """
        set_threshold(baz_radar_detector_sptr self, float threshold)



        Params: (threshold)
        """
        return _baz_swig.baz_radar_detector_sptr_set_threshold(self, threshold)


    def set_pulse_plateau(self, level):
        """
        set_pulse_plateau(baz_radar_detector_sptr self, float level)



        Params: (level)
        """
        return _baz_swig.baz_radar_detector_sptr_set_pulse_plateau(self, level)


    def set_param(self, param, value):
        """
        set_param(baz_radar_detector_sptr self, std::string const & param, float value) -> bool



        Params: (param, value)
        """
        return _baz_swig.baz_radar_detector_sptr_set_param(self, param, value)


    def skip(self, skip):
        """
        skip(baz_radar_detector_sptr self, int skip)



        Params: (skip)
        """
        return _baz_swig.baz_radar_detector_sptr_skip(self, skip)


    def history(self):
        """history(baz_radar_detector_sptr self) -> unsigned int"""
        return _baz_swig.baz_radar_detector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_radar_detector_sptr self, int which, int delay)
        declare_sample_delay(baz_radar_detector_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_radar_detector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_radar_detector_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_radar_detector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_radar_detector_sptr self) -> int"""
        return _baz_swig.baz_radar_detector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_radar_detector_sptr self) -> double"""
        return _baz_swig.baz_radar_detector_sptr_relative_rate(self)


    def start(self):
        """start(baz_radar_detector_sptr self) -> bool"""
        return _baz_swig.baz_radar_detector_sptr_start(self)


    def stop(self):
        """stop(baz_radar_detector_sptr self) -> bool"""
        return _baz_swig.baz_radar_detector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_radar_detector_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_radar_detector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_radar_detector_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_radar_detector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_radar_detector_sptr self) -> int"""
        return _baz_swig.baz_radar_detector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_radar_detector_sptr self, int m)"""
        return _baz_swig.baz_radar_detector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_radar_detector_sptr self)"""
        return _baz_swig.baz_radar_detector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_radar_detector_sptr self) -> bool"""
        return _baz_swig.baz_radar_detector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_radar_detector_sptr self, int m)"""
        return _baz_swig.baz_radar_detector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_radar_detector_sptr self) -> int"""
        return _baz_swig.baz_radar_detector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_radar_detector_sptr self, int i) -> long"""
        return _baz_swig.baz_radar_detector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_radar_detector_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_radar_detector_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_radar_detector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_radar_detector_sptr self, int i) -> long"""
        return _baz_swig.baz_radar_detector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_radar_detector_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_radar_detector_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_radar_detector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_radar_detector_sptr self, int which) -> float
        pc_input_buffers_full(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_radar_detector_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_radar_detector_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_radar_detector_sptr self, int which) -> float
        pc_output_buffers_full(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_radar_detector_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_radar_detector_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_radar_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_radar_detector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_radar_detector_sptr self) -> float"""
        return _baz_swig.baz_radar_detector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_radar_detector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_radar_detector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_radar_detector_sptr self)"""
        return _baz_swig.baz_radar_detector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_radar_detector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_radar_detector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_radar_detector_sptr self) -> int"""
        return _baz_swig.baz_radar_detector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_radar_detector_sptr self) -> int"""
        return _baz_swig.baz_radar_detector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_radar_detector_sptr self, int priority) -> int"""
        return _baz_swig.baz_radar_detector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_radar_detector_sptr self) -> std::string"""
        return _baz_swig.baz_radar_detector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_radar_detector_sptr self) -> std::string"""
        return _baz_swig.baz_radar_detector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_radar_detector_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_radar_detector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_radar_detector_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_radar_detector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_radar_detector_sptr self) -> long"""
        return _baz_swig.baz_radar_detector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_radar_detector_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_radar_detector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_radar_detector_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_radar_detector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_radar_detector_sptr self) -> std::string"""
        return _baz_swig.baz_radar_detector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_radar_detector_sptr self, std::string name)"""
        return _baz_swig.baz_radar_detector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_radar_detector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_radar_detector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_radar_detector_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_radar_detector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_radar_detector_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_radar_detector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_radar_detector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_radar_detector_sptr_message_subscribers(self, which_port)

baz_radar_detector_sptr_swigregister = _baz_swig.baz_radar_detector_sptr_swigregister
baz_radar_detector_sptr_swigregister(baz_radar_detector_sptr)


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


def radar_detector(sample_rate, msgq):
    """
    radar_detector(int sample_rate, msg_queue_sptr msgq) -> baz_radar_detector_sptr

    radar_detector a stream of floats.

    This uses the preferred technique: subclassing gr_sync_block.

    Return a shared_ptr to a new instance of baz_radar_detector.

    To avoid accidental use of raw pointers, baz_radar_detector's constructor is private. baz_make_block_status is the public interface for creating new instances.

    Params: (sample_rate, msgq)
    """
    return _baz_swig.radar_detector(sample_rate, msgq)
class baz_fastrak_decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_fastrak_decoder)> class."""

    thisown = _swig_property(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<(baz_fastrak_decoder)> self) -> baz_fastrak_decoder_sptr
        __init__(boost::shared_ptr<(baz_fastrak_decoder)> self, baz_fastrak_decoder * p) -> baz_fastrak_decoder_sptr
        """
        this = _baz_swig.new_baz_fastrak_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_fastrak_decoder_sptr self) -> baz_fastrak_decoder *"""
        return _baz_swig.baz_fastrak_decoder_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_fastrak_decoder_sptr
    __del__ = lambda self: None

    def set_sync_threshold(self, threshold):
        """
        set_sync_threshold(baz_fastrak_decoder_sptr self, float threshold)



        Params: (threshold)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_set_sync_threshold(self, threshold)


    def last_id_count(self, reset=False):
        """
        last_id_count(baz_fastrak_decoder_sptr self, bool reset=False) -> unsigned int



        Params: (reset)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_last_id_count(self, reset)


    def last_id(self):
        """
        last_id(baz_fastrak_decoder_sptr self) -> unsigned int



        Params: (NONE)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_last_id(self)


    def history(self):
        """history(baz_fastrak_decoder_sptr self) -> unsigned int"""
        return _baz_swig.baz_fastrak_decoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_fastrak_decoder_sptr self, int which, int delay)
        declare_sample_delay(baz_fastrak_decoder_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_fastrak_decoder_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_fastrak_decoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_fastrak_decoder_sptr self) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_fastrak_decoder_sptr self) -> double"""
        return _baz_swig.baz_fastrak_decoder_sptr_relative_rate(self)


    def start(self):
        """start(baz_fastrak_decoder_sptr self) -> bool"""
        return _baz_swig.baz_fastrak_decoder_sptr_start(self)


    def stop(self):
        """stop(baz_fastrak_decoder_sptr self) -> bool"""
        return _baz_swig.baz_fastrak_decoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_fastrak_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_fastrak_decoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_fastrak_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_fastrak_decoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_fastrak_decoder_sptr self) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_fastrak_decoder_sptr self, int m)"""
        return _baz_swig.baz_fastrak_decoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_fastrak_decoder_sptr self)"""
        return _baz_swig.baz_fastrak_decoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_fastrak_decoder_sptr self) -> bool"""
        return _baz_swig.baz_fastrak_decoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_fastrak_decoder_sptr self, int m)"""
        return _baz_swig.baz_fastrak_decoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_fastrak_decoder_sptr self) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_fastrak_decoder_sptr self, int i) -> long"""
        return _baz_swig.baz_fastrak_decoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_fastrak_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_fastrak_decoder_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_fastrak_decoder_sptr self, int i) -> long"""
        return _baz_swig.baz_fastrak_decoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_fastrak_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_fastrak_decoder_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_fastrak_decoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_fastrak_decoder_sptr self, int which) -> float
        pc_input_buffers_full(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_fastrak_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_fastrak_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_fastrak_decoder_sptr self, int which) -> float
        pc_output_buffers_full(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_fastrak_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_fastrak_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_fastrak_decoder_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_fastrak_decoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_fastrak_decoder_sptr self) -> float"""
        return _baz_swig.baz_fastrak_decoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_fastrak_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_fastrak_decoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_fastrak_decoder_sptr self)"""
        return _baz_swig.baz_fastrak_decoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_fastrak_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_fastrak_decoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_fastrak_decoder_sptr self) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_fastrak_decoder_sptr self) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_fastrak_decoder_sptr self, int priority) -> int"""
        return _baz_swig.baz_fastrak_decoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_fastrak_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_fastrak_decoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_fastrak_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_fastrak_decoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_fastrak_decoder_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_fastrak_decoder_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_fastrak_decoder_sptr self) -> long"""
        return _baz_swig.baz_fastrak_decoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_fastrak_decoder_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_fastrak_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_fastrak_decoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_fastrak_decoder_sptr self) -> std::string"""
        return _baz_swig.baz_fastrak_decoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_fastrak_decoder_sptr self, std::string name)"""
        return _baz_swig.baz_fastrak_decoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_fastrak_decoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_fastrak_decoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_fastrak_decoder_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_fastrak_decoder_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_fastrak_decoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_fastrak_decoder_sptr_message_subscribers(self, which_port)

baz_fastrak_decoder_sptr_swigregister = _baz_swig.baz_fastrak_decoder_sptr_swigregister
baz_fastrak_decoder_sptr_swigregister(baz_fastrak_decoder_sptr)


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


def fastrak_decoder(sample_rate):
    """
    fastrak_decoder(int sample_rate) -> baz_fastrak_decoder_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr_sync_block.

    Return a shared_ptr to a new instance of baz_fastrak_decoder.

    To avoid accidental use of raw pointers, baz_fastrak_decoder's constructor is private. baz_make_fastrak_decoder is the public interface for creating new instances.

    Params: (sample_rate)
    """
    return _baz_swig.fastrak_decoder(sample_rate)
class baz_overlap_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_overlap)> class."""

    thisown = _swig_property(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<(baz_overlap)> self) -> baz_overlap_sptr
        __init__(boost::shared_ptr<(baz_overlap)> self, baz_overlap * p) -> baz_overlap_sptr
        """
        this = _baz_swig.new_baz_overlap_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_overlap_sptr self) -> baz_overlap *"""
        return _baz_swig.baz_overlap_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_overlap_sptr
    __del__ = lambda self: None

    def set_overlap(self, overlap):
        """
        set_overlap(baz_overlap_sptr self, int overlap)



        Params: (overlap)
        """
        return _baz_swig.baz_overlap_sptr_set_overlap(self, overlap)


    def history(self):
        """history(baz_overlap_sptr self) -> unsigned int"""
        return _baz_swig.baz_overlap_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_overlap_sptr self, int which, int delay)
        declare_sample_delay(baz_overlap_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_overlap_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_overlap_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_overlap_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_overlap_sptr self) -> int"""
        return _baz_swig.baz_overlap_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_overlap_sptr self) -> double"""
        return _baz_swig.baz_overlap_sptr_relative_rate(self)


    def start(self):
        """start(baz_overlap_sptr self) -> bool"""
        return _baz_swig.baz_overlap_sptr_start(self)


    def stop(self):
        """stop(baz_overlap_sptr self) -> bool"""
        return _baz_swig.baz_overlap_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_overlap_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_overlap_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_overlap_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_overlap_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_overlap_sptr self) -> int"""
        return _baz_swig.baz_overlap_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_overlap_sptr self, int m)"""
        return _baz_swig.baz_overlap_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_overlap_sptr self)"""
        return _baz_swig.baz_overlap_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_overlap_sptr self) -> bool"""
        return _baz_swig.baz_overlap_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_overlap_sptr self, int m)"""
        return _baz_swig.baz_overlap_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_overlap_sptr self) -> int"""
        return _baz_swig.baz_overlap_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_overlap_sptr self, int i) -> long"""
        return _baz_swig.baz_overlap_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_overlap_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_overlap_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_overlap_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_overlap_sptr self, int i) -> long"""
        return _baz_swig.baz_overlap_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_overlap_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_overlap_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_overlap_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_overlap_sptr self, int which) -> float
        pc_input_buffers_full(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_overlap_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_overlap_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_overlap_sptr self, int which) -> float
        pc_output_buffers_full(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_overlap_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_overlap_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_overlap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_overlap_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_overlap_sptr self) -> float"""
        return _baz_swig.baz_overlap_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_overlap_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_overlap_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_overlap_sptr self)"""
        return _baz_swig.baz_overlap_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_overlap_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_overlap_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_overlap_sptr self) -> int"""
        return _baz_swig.baz_overlap_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_overlap_sptr self) -> int"""
        return _baz_swig.baz_overlap_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_overlap_sptr self, int priority) -> int"""
        return _baz_swig.baz_overlap_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_overlap_sptr self) -> std::string"""
        return _baz_swig.baz_overlap_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_overlap_sptr self) -> std::string"""
        return _baz_swig.baz_overlap_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_overlap_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_overlap_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_overlap_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_overlap_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_overlap_sptr self) -> long"""
        return _baz_swig.baz_overlap_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_overlap_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_overlap_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_overlap_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_overlap_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_overlap_sptr self) -> std::string"""
        return _baz_swig.baz_overlap_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_overlap_sptr self, std::string name)"""
        return _baz_swig.baz_overlap_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_overlap_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_overlap_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_overlap_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_overlap_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_overlap_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_overlap_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_overlap_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_overlap_sptr_message_subscribers(self, which_port)

baz_overlap_sptr_swigregister = _baz_swig.baz_overlap_sptr_swigregister
baz_overlap_sptr_swigregister(baz_overlap_sptr)


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


def overlap(item_size, vlen, overlap):
    """
    overlap(int item_size, int vlen, int overlap) -> baz_overlap_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_pow_cc.

    To avoid accidental use of raw pointers, baz_pow_cc's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, vlen, overlap)
    """
    return _baz_swig.overlap(item_size, vlen, overlap)
class baz_manchester_decode_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_manchester_decode_bb)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_manchester_decode_bb)> self) -> baz_manchester_decode_bb_sptr
        __init__(boost::shared_ptr<(baz_manchester_decode_bb)> self, baz_manchester_decode_bb * p) -> baz_manchester_decode_bb_sptr
        """
        this = _baz_swig.new_baz_manchester_decode_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_manchester_decode_bb_sptr self) -> baz_manchester_decode_bb *"""
        return _baz_swig.baz_manchester_decode_bb_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_manchester_decode_bb_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_manchester_decode_bb_sptr self) -> unsigned int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_manchester_decode_bb_sptr self, int which, int delay)
        declare_sample_delay(baz_manchester_decode_bb_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_manchester_decode_bb_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_manchester_decode_bb_sptr self) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_manchester_decode_bb_sptr self) -> double"""
        return _baz_swig.baz_manchester_decode_bb_sptr_relative_rate(self)


    def start(self):
        """start(baz_manchester_decode_bb_sptr self) -> bool"""
        return _baz_swig.baz_manchester_decode_bb_sptr_start(self)


    def stop(self):
        """stop(baz_manchester_decode_bb_sptr self) -> bool"""
        return _baz_swig.baz_manchester_decode_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_manchester_decode_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_manchester_decode_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_manchester_decode_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_manchester_decode_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_manchester_decode_bb_sptr self) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_manchester_decode_bb_sptr self, int m)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_manchester_decode_bb_sptr self)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_manchester_decode_bb_sptr self) -> bool"""
        return _baz_swig.baz_manchester_decode_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_manchester_decode_bb_sptr self, int m)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_manchester_decode_bb_sptr self) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_manchester_decode_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_manchester_decode_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_manchester_decode_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_manchester_decode_bb_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_manchester_decode_bb_sptr self, int i) -> long"""
        return _baz_swig.baz_manchester_decode_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_manchester_decode_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_manchester_decode_bb_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_input_buffers_full(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_output_buffers_full(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_manchester_decode_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_manchester_decode_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_manchester_decode_bb_sptr self) -> float"""
        return _baz_swig.baz_manchester_decode_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_manchester_decode_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_manchester_decode_bb_sptr self)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_manchester_decode_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_manchester_decode_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_manchester_decode_bb_sptr self) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_manchester_decode_bb_sptr self) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_manchester_decode_bb_sptr self, int priority) -> int"""
        return _baz_swig.baz_manchester_decode_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_manchester_decode_bb_sptr self) -> std::string"""
        return _baz_swig.baz_manchester_decode_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_manchester_decode_bb_sptr self) -> std::string"""
        return _baz_swig.baz_manchester_decode_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_manchester_decode_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_manchester_decode_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_manchester_decode_bb_sptr self) -> long"""
        return _baz_swig.baz_manchester_decode_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_manchester_decode_bb_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_manchester_decode_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_manchester_decode_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_manchester_decode_bb_sptr self) -> std::string"""
        return _baz_swig.baz_manchester_decode_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_manchester_decode_bb_sptr self, std::string name)"""
        return _baz_swig.baz_manchester_decode_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_manchester_decode_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_manchester_decode_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_manchester_decode_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_manchester_decode_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_manchester_decode_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_manchester_decode_bb_sptr_message_subscribers(self, which_port)

baz_manchester_decode_bb_sptr_swigregister = _baz_swig.baz_manchester_decode_bb_sptr_swigregister
baz_manchester_decode_bb_sptr_swigregister(baz_manchester_decode_bb_sptr)


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


def manchester_decode_bb(original, threshold, window, verbose=False, show_bits=False):
    """
    manchester_decode_bb(bool original, int threshold, int window, bool verbose=False, bool show_bits=False) -> baz_manchester_decode_bb_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_manchester_decode_bb.

    To avoid accidental use of raw pointers, baz_manchester_decode_bb's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (original, threshold, window, verbose, show_bits)
    """
    return _baz_swig.manchester_decode_bb(original, threshold, window, verbose, show_bits)
class baz_sweep_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_sweep)> class."""

    thisown = _swig_property(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<(baz_sweep)> self) -> baz_sweep_sptr
        __init__(boost::shared_ptr<(baz_sweep)> self, baz_sweep * p) -> baz_sweep_sptr
        """
        this = _baz_swig.new_baz_sweep_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_sweep_sptr self) -> baz_sweep *"""
        return _baz_swig.baz_sweep_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_sweep_sptr
    __del__ = lambda self: None

    def sweep(self, freq, rate=-1.0, is_duration=False, block=False):
        """
        sweep(baz_sweep_sptr self, float freq, float rate=-1.0, bool is_duration=False, bool block=False)



        Params: (freq, rate, is_duration, block)
        """
        return _baz_swig.baz_sweep_sptr_sweep(self, freq, rate, is_duration, block)


    def history(self):
        """history(baz_sweep_sptr self) -> unsigned int"""
        return _baz_swig.baz_sweep_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_sweep_sptr self, int which, int delay)
        declare_sample_delay(baz_sweep_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_sweep_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_sweep_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_sweep_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_sweep_sptr self) -> int"""
        return _baz_swig.baz_sweep_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_sweep_sptr self) -> double"""
        return _baz_swig.baz_sweep_sptr_relative_rate(self)


    def start(self):
        """start(baz_sweep_sptr self) -> bool"""
        return _baz_swig.baz_sweep_sptr_start(self)


    def stop(self):
        """stop(baz_sweep_sptr self) -> bool"""
        return _baz_swig.baz_sweep_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_sweep_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_sweep_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_sweep_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_sweep_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_sweep_sptr self) -> int"""
        return _baz_swig.baz_sweep_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_sweep_sptr self, int m)"""
        return _baz_swig.baz_sweep_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_sweep_sptr self)"""
        return _baz_swig.baz_sweep_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_sweep_sptr self) -> bool"""
        return _baz_swig.baz_sweep_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_sweep_sptr self, int m)"""
        return _baz_swig.baz_sweep_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_sweep_sptr self) -> int"""
        return _baz_swig.baz_sweep_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_sweep_sptr self, int i) -> long"""
        return _baz_swig.baz_sweep_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_sweep_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_sweep_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_sweep_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_sweep_sptr self, int i) -> long"""
        return _baz_swig.baz_sweep_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_sweep_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_sweep_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_sweep_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_sweep_sptr self, int which) -> float
        pc_input_buffers_full(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_sweep_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_sweep_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_sweep_sptr self, int which) -> float
        pc_output_buffers_full(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_sweep_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_sweep_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_sweep_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_sweep_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_sweep_sptr self) -> float"""
        return _baz_swig.baz_sweep_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_sweep_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_sweep_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_sweep_sptr self)"""
        return _baz_swig.baz_sweep_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_sweep_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_sweep_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_sweep_sptr self) -> int"""
        return _baz_swig.baz_sweep_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_sweep_sptr self) -> int"""
        return _baz_swig.baz_sweep_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_sweep_sptr self, int priority) -> int"""
        return _baz_swig.baz_sweep_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_sweep_sptr self) -> std::string"""
        return _baz_swig.baz_sweep_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_sweep_sptr self) -> std::string"""
        return _baz_swig.baz_sweep_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_sweep_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_sweep_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_sweep_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_sweep_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_sweep_sptr self) -> long"""
        return _baz_swig.baz_sweep_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_sweep_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_sweep_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_sweep_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_sweep_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_sweep_sptr self) -> std::string"""
        return _baz_swig.baz_sweep_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_sweep_sptr self, std::string name)"""
        return _baz_swig.baz_sweep_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_sweep_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_sweep_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_sweep_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_sweep_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_sweep_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_sweep_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_sweep_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_sweep_sptr_message_subscribers(self, which_port)

baz_sweep_sptr_swigregister = _baz_swig.baz_sweep_sptr_swigregister
baz_sweep_sptr_swigregister(baz_sweep_sptr)


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


def sweep(samp_rate, sweep_rate=0.0, is_duration=False):
    """
    sweep(float samp_rate, float sweep_rate=0.0, bool is_duration=False) -> baz_sweep_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_sweep.

    To avoid accidental use of raw pointers, baz_sweep's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (samp_rate, sweep_rate, is_duration)
    """
    return _baz_swig.sweep(samp_rate, sweep_rate, is_duration)
class baz_merge_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_merge)> class."""

    thisown = _swig_property(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<(baz_merge)> self) -> baz_merge_sptr
        __init__(boost::shared_ptr<(baz_merge)> self, baz_merge * p) -> baz_merge_sptr
        """
        this = _baz_swig.new_baz_merge_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_merge_sptr self) -> baz_merge *"""
        return _baz_swig.baz_merge_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_merge_sptr
    __del__ = lambda self: None

    def set_start_time(self, *args):
        """
        set_start_time(baz_merge_sptr self, double time)
        set_start_time(baz_merge_sptr self, uint64_t whole, double frac)



        Params: (time)
        """
        return _baz_swig.baz_merge_sptr_set_start_time(self, *args)


    def history(self):
        """history(baz_merge_sptr self) -> unsigned int"""
        return _baz_swig.baz_merge_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_merge_sptr self, int which, int delay)
        declare_sample_delay(baz_merge_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_merge_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_merge_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_merge_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_merge_sptr self) -> int"""
        return _baz_swig.baz_merge_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_merge_sptr self) -> double"""
        return _baz_swig.baz_merge_sptr_relative_rate(self)


    def start(self):
        """start(baz_merge_sptr self) -> bool"""
        return _baz_swig.baz_merge_sptr_start(self)


    def stop(self):
        """stop(baz_merge_sptr self) -> bool"""
        return _baz_swig.baz_merge_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_merge_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_merge_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_merge_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_merge_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_merge_sptr self) -> int"""
        return _baz_swig.baz_merge_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_merge_sptr self, int m)"""
        return _baz_swig.baz_merge_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_merge_sptr self)"""
        return _baz_swig.baz_merge_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_merge_sptr self) -> bool"""
        return _baz_swig.baz_merge_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_merge_sptr self, int m)"""
        return _baz_swig.baz_merge_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_merge_sptr self) -> int"""
        return _baz_swig.baz_merge_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_merge_sptr self, int i) -> long"""
        return _baz_swig.baz_merge_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_merge_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_merge_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_merge_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_merge_sptr self, int i) -> long"""
        return _baz_swig.baz_merge_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_merge_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_merge_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_merge_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_merge_sptr self, int which) -> float
        pc_input_buffers_full(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_merge_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_merge_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_merge_sptr self, int which) -> float
        pc_output_buffers_full(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_merge_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_merge_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_merge_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_merge_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_merge_sptr self) -> float"""
        return _baz_swig.baz_merge_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_merge_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_merge_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_merge_sptr self)"""
        return _baz_swig.baz_merge_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_merge_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_merge_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_merge_sptr self) -> int"""
        return _baz_swig.baz_merge_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_merge_sptr self) -> int"""
        return _baz_swig.baz_merge_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_merge_sptr self, int priority) -> int"""
        return _baz_swig.baz_merge_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_merge_sptr self) -> std::string"""
        return _baz_swig.baz_merge_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_merge_sptr self) -> std::string"""
        return _baz_swig.baz_merge_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_merge_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_merge_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_merge_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_merge_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_merge_sptr self) -> long"""
        return _baz_swig.baz_merge_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_merge_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_merge_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_merge_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_merge_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_merge_sptr self) -> std::string"""
        return _baz_swig.baz_merge_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_merge_sptr self, std::string name)"""
        return _baz_swig.baz_merge_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_merge_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_merge_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_merge_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_merge_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_merge_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_merge_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_merge_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_merge_sptr_message_subscribers(self, which_port)

baz_merge_sptr_swigregister = _baz_swig.baz_merge_sptr_swigregister
baz_merge_sptr_swigregister(baz_merge_sptr)


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


def merge(*args, **kwargs):
    """
    merge(int item_size, float samp_rate, int additional_streams=1, bool drop_residual=True, char const * length_tag, char const * ignore_tag, bool verbose=False) -> baz_merge_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_merge.

    To avoid accidental use of raw pointers, baz_merge's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (item_size, samp_rate, additional_streams, drop_residual, length_tag, ignore_tag, verbose)
    """
    return _baz_swig.merge(*args, **kwargs)
class baz_tcp_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_tcp_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<(baz_tcp_sink)> self) -> baz_tcp_sink_sptr
        __init__(boost::shared_ptr<(baz_tcp_sink)> self, baz_tcp_sink * p) -> baz_tcp_sink_sptr
        """
        this = _baz_swig.new_baz_tcp_sink_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_tcp_sink_sptr self) -> baz_tcp_sink *"""
        return _baz_swig.baz_tcp_sink_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_tcp_sink_sptr
    __del__ = lambda self: None

    def connect(self, host, port):
        """
        connect(baz_tcp_sink_sptr self, char const * host, unsigned short port) -> bool

        Change the connection to a new destination.

        Calls disconnect() to terminate any current connection first.

        Params: (host, port)
        """
        return _baz_swig.baz_tcp_sink_sptr_connect(self, host, port)


    def disconnect(self):
        """
        disconnect(baz_tcp_sink_sptr self)

        Send zero-length packet (if eof is requested) then stop sending.

        Zero-byte packets can be interpreted as EOF by gr_udp_source. Note that disconnect occurs automatically when the sink is destroyed, but not when its top_block stops.

        Params: (NONE)
        """
        return _baz_swig.baz_tcp_sink_sptr_disconnect(self)


    def set_status_msgq(self, queue):
        """
        set_status_msgq(baz_tcp_sink_sptr self, msg_queue_sptr queue)



        Params: (queue)
        """
        return _baz_swig.baz_tcp_sink_sptr_set_status_msgq(self, queue)


    def history(self):
        """history(baz_tcp_sink_sptr self) -> unsigned int"""
        return _baz_swig.baz_tcp_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_tcp_sink_sptr self, int which, int delay)
        declare_sample_delay(baz_tcp_sink_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_tcp_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_tcp_sink_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_tcp_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_tcp_sink_sptr self) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_tcp_sink_sptr self) -> double"""
        return _baz_swig.baz_tcp_sink_sptr_relative_rate(self)


    def start(self):
        """start(baz_tcp_sink_sptr self) -> bool"""
        return _baz_swig.baz_tcp_sink_sptr_start(self)


    def stop(self):
        """stop(baz_tcp_sink_sptr self) -> bool"""
        return _baz_swig.baz_tcp_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_tcp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_tcp_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_tcp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_tcp_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_tcp_sink_sptr self) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_tcp_sink_sptr self, int m)"""
        return _baz_swig.baz_tcp_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_tcp_sink_sptr self)"""
        return _baz_swig.baz_tcp_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_tcp_sink_sptr self) -> bool"""
        return _baz_swig.baz_tcp_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_tcp_sink_sptr self, int m)"""
        return _baz_swig.baz_tcp_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_tcp_sink_sptr self) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_tcp_sink_sptr self, int i) -> long"""
        return _baz_swig.baz_tcp_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_tcp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_tcp_sink_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_tcp_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_tcp_sink_sptr self, int i) -> long"""
        return _baz_swig.baz_tcp_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_tcp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_tcp_sink_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_tcp_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_tcp_sink_sptr self, int which) -> float
        pc_input_buffers_full(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_tcp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_tcp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_tcp_sink_sptr self, int which) -> float
        pc_output_buffers_full(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_tcp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_tcp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_tcp_sink_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_tcp_sink_sptr self) -> float"""
        return _baz_swig.baz_tcp_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_tcp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_tcp_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_tcp_sink_sptr self)"""
        return _baz_swig.baz_tcp_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_tcp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_tcp_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_tcp_sink_sptr self) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_tcp_sink_sptr self) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_tcp_sink_sptr self, int priority) -> int"""
        return _baz_swig.baz_tcp_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_tcp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_tcp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_tcp_sink_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tcp_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_tcp_sink_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tcp_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_tcp_sink_sptr self) -> long"""
        return _baz_swig.baz_tcp_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_tcp_sink_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_tcp_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_tcp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_tcp_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_tcp_sink_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_tcp_sink_sptr self, std::string name)"""
        return _baz_swig.baz_tcp_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_tcp_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_tcp_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_tcp_sink_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_tcp_sink_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_tcp_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_sink_sptr_message_subscribers(self, which_port)

baz_tcp_sink_sptr_swigregister = _baz_swig.baz_tcp_sink_sptr_swigregister
baz_tcp_sink_sptr_swigregister(baz_tcp_sink_sptr)


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


def tcp_sink(itemsize, host, port, blocking=True, auto_reconnect=False, verbose=False):
    """
    tcp_sink(size_t itemsize, char const * host, unsigned short port, bool blocking=True, bool auto_reconnect=False, bool verbose=False) -> baz_tcp_sink_sptr

    Write stream to an TCP socket.

    Params: (itemsize, host, port, blocking, auto_reconnect, verbose)
    """
    return _baz_swig.tcp_sink(itemsize, host, port, blocking, auto_reconnect, verbose)
class baz_tcp_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_tcp_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<(baz_tcp_source)> self) -> baz_tcp_source_sptr
        __init__(boost::shared_ptr<(baz_tcp_source)> self, baz_tcp_source * p) -> baz_tcp_source_sptr
        """
        this = _baz_swig.new_baz_tcp_source_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_tcp_source_sptr self) -> baz_tcp_source *"""
        return _baz_swig.baz_tcp_source_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_tcp_source_sptr
    __del__ = lambda self: None

    def get_port(self):
        """
        get_port(baz_tcp_source_sptr self) -> int

        return the port number of the socket

        Params: (NONE)
        """
        return _baz_swig.baz_tcp_source_sptr_get_port(self)


    def signal_eos(self):
        """
        signal_eos(baz_tcp_source_sptr self)



        Params: (NONE)
        """
        return _baz_swig.baz_tcp_source_sptr_signal_eos(self)


    def history(self):
        """history(baz_tcp_source_sptr self) -> unsigned int"""
        return _baz_swig.baz_tcp_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_tcp_source_sptr self, int which, int delay)
        declare_sample_delay(baz_tcp_source_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_tcp_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_tcp_source_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_tcp_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_tcp_source_sptr self) -> int"""
        return _baz_swig.baz_tcp_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_tcp_source_sptr self) -> double"""
        return _baz_swig.baz_tcp_source_sptr_relative_rate(self)


    def start(self):
        """start(baz_tcp_source_sptr self) -> bool"""
        return _baz_swig.baz_tcp_source_sptr_start(self)


    def stop(self):
        """stop(baz_tcp_source_sptr self) -> bool"""
        return _baz_swig.baz_tcp_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_tcp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_tcp_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_tcp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_tcp_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_tcp_source_sptr self) -> int"""
        return _baz_swig.baz_tcp_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_tcp_source_sptr self, int m)"""
        return _baz_swig.baz_tcp_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_tcp_source_sptr self)"""
        return _baz_swig.baz_tcp_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_tcp_source_sptr self) -> bool"""
        return _baz_swig.baz_tcp_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_tcp_source_sptr self, int m)"""
        return _baz_swig.baz_tcp_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_tcp_source_sptr self) -> int"""
        return _baz_swig.baz_tcp_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_tcp_source_sptr self, int i) -> long"""
        return _baz_swig.baz_tcp_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_tcp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_tcp_source_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_tcp_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_tcp_source_sptr self, int i) -> long"""
        return _baz_swig.baz_tcp_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_tcp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_tcp_source_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_tcp_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_tcp_source_sptr self, int which) -> float
        pc_input_buffers_full(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_tcp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_tcp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_tcp_source_sptr self, int which) -> float
        pc_output_buffers_full(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_tcp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_tcp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_tcp_source_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_tcp_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_tcp_source_sptr self) -> float"""
        return _baz_swig.baz_tcp_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_tcp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_tcp_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_tcp_source_sptr self)"""
        return _baz_swig.baz_tcp_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_tcp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_tcp_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_tcp_source_sptr self) -> int"""
        return _baz_swig.baz_tcp_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_tcp_source_sptr self) -> int"""
        return _baz_swig.baz_tcp_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_tcp_source_sptr self, int priority) -> int"""
        return _baz_swig.baz_tcp_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_tcp_source_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_tcp_source_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_tcp_source_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tcp_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_tcp_source_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_tcp_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_tcp_source_sptr self) -> long"""
        return _baz_swig.baz_tcp_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_tcp_source_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_tcp_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_tcp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_tcp_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_tcp_source_sptr self) -> std::string"""
        return _baz_swig.baz_tcp_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_tcp_source_sptr self, std::string name)"""
        return _baz_swig.baz_tcp_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_tcp_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_tcp_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_tcp_source_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_tcp_source_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_tcp_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_tcp_source_sptr_message_subscribers(self, which_port)

baz_tcp_source_sptr_swigregister = _baz_swig.baz_tcp_source_sptr_swigregister
baz_tcp_source_sptr_swigregister(baz_tcp_source_sptr)


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


def tcp_source(itemsize, host, port, buffer_size=0, verbose=False):
    """
    tcp_source(size_t itemsize, char const * host, unsigned short port, int buffer_size=0, bool verbose=False) -> baz_tcp_source_sptr

    Read stream from an UDP socket.

    Params: (itemsize, host, port, buffer_size, verbose)
    """
    return _baz_swig.tcp_source(itemsize, host, port, buffer_size, verbose)
class baz_auto_ber_bf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_auto_ber_bf)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_auto_ber_bf)> self) -> baz_auto_ber_bf_sptr
        __init__(boost::shared_ptr<(baz_auto_ber_bf)> self, baz_auto_ber_bf * p) -> baz_auto_ber_bf_sptr
        """
        this = _baz_swig.new_baz_auto_ber_bf_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_auto_ber_bf_sptr self) -> baz_auto_ber_bf *"""
        return _baz_swig.baz_auto_ber_bf_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_auto_ber_bf_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_auto_ber_bf_sptr self) -> unsigned int"""
        return _baz_swig.baz_auto_ber_bf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_auto_ber_bf_sptr self, int which, int delay)
        declare_sample_delay(baz_auto_ber_bf_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_auto_ber_bf_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_auto_ber_bf_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_auto_ber_bf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_auto_ber_bf_sptr self) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_auto_ber_bf_sptr self) -> double"""
        return _baz_swig.baz_auto_ber_bf_sptr_relative_rate(self)


    def start(self):
        """start(baz_auto_ber_bf_sptr self) -> bool"""
        return _baz_swig.baz_auto_ber_bf_sptr_start(self)


    def stop(self):
        """stop(baz_auto_ber_bf_sptr self) -> bool"""
        return _baz_swig.baz_auto_ber_bf_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_auto_ber_bf_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_auto_ber_bf_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_auto_ber_bf_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_auto_ber_bf_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_auto_ber_bf_sptr self) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_auto_ber_bf_sptr self, int m)"""
        return _baz_swig.baz_auto_ber_bf_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_auto_ber_bf_sptr self)"""
        return _baz_swig.baz_auto_ber_bf_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_auto_ber_bf_sptr self) -> bool"""
        return _baz_swig.baz_auto_ber_bf_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_auto_ber_bf_sptr self, int m)"""
        return _baz_swig.baz_auto_ber_bf_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_auto_ber_bf_sptr self) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_auto_ber_bf_sptr self, int i) -> long"""
        return _baz_swig.baz_auto_ber_bf_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_auto_ber_bf_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_auto_ber_bf_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_auto_ber_bf_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_auto_ber_bf_sptr self, int i) -> long"""
        return _baz_swig.baz_auto_ber_bf_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_auto_ber_bf_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_auto_ber_bf_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_auto_ber_bf_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_auto_ber_bf_sptr self, int which) -> float
        pc_input_buffers_full(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_auto_ber_bf_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_auto_ber_bf_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_auto_ber_bf_sptr self, int which) -> float
        pc_output_buffers_full(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_auto_ber_bf_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_auto_ber_bf_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_auto_ber_bf_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_auto_ber_bf_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_auto_ber_bf_sptr self) -> float"""
        return _baz_swig.baz_auto_ber_bf_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_auto_ber_bf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_auto_ber_bf_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_auto_ber_bf_sptr self)"""
        return _baz_swig.baz_auto_ber_bf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_auto_ber_bf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_auto_ber_bf_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_auto_ber_bf_sptr self) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_auto_ber_bf_sptr self) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_auto_ber_bf_sptr self, int priority) -> int"""
        return _baz_swig.baz_auto_ber_bf_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_auto_ber_bf_sptr self) -> std::string"""
        return _baz_swig.baz_auto_ber_bf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_auto_ber_bf_sptr self) -> std::string"""
        return _baz_swig.baz_auto_ber_bf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_auto_ber_bf_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_auto_ber_bf_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_auto_ber_bf_sptr self) -> long"""
        return _baz_swig.baz_auto_ber_bf_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_auto_ber_bf_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_auto_ber_bf_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_auto_ber_bf_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_auto_ber_bf_sptr self) -> std::string"""
        return _baz_swig.baz_auto_ber_bf_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_auto_ber_bf_sptr self, std::string name)"""
        return _baz_swig.baz_auto_ber_bf_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_auto_ber_bf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_auto_ber_bf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_auto_ber_bf_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_auto_ber_bf_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_auto_ber_bf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_auto_ber_bf_sptr_message_subscribers(self, which_port)

baz_auto_ber_bf_sptr_swigregister = _baz_swig.baz_auto_ber_bf_sptr_swigregister
baz_auto_ber_bf_sptr_swigregister(baz_auto_ber_bf_sptr)


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


def auto_ber_bf(degree, sync_bits, sync_decim):
    """
    auto_ber_bf(int degree, int sync_bits, int sync_decim) -> baz_auto_ber_bf_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_auto_ber_bf.

    To avoid accidental use of raw pointers, baz_auto_ber_bf's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (degree, sync_bits, sync_decim)
    """
    return _baz_swig.auto_ber_bf(degree, sync_bits, sync_decim)
class baz_peak_detector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_peak_detector)> class."""

    thisown = _swig_property(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<(baz_peak_detector)> self) -> baz_peak_detector_sptr
        __init__(boost::shared_ptr<(baz_peak_detector)> self, baz_peak_detector * p) -> baz_peak_detector_sptr
        """
        this = _baz_swig.new_baz_peak_detector_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_peak_detector_sptr self) -> baz_peak_detector *"""
        return _baz_swig.baz_peak_detector_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_peak_detector_sptr
    __del__ = lambda self: None

    def set_threshold(self, threshold):
        """
        set_threshold(baz_peak_detector_sptr self, float threshold)



        Params: (threshold)
        """
        return _baz_swig.baz_peak_detector_sptr_set_threshold(self, threshold)


    def unset_threshold(self):
        """
        unset_threshold(baz_peak_detector_sptr self)



        Params: (NONE)
        """
        return _baz_swig.baz_peak_detector_sptr_unset_threshold(self)


    def threshold(self):
        """
        threshold(baz_peak_detector_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.baz_peak_detector_sptr_threshold(self)


    def threshold_set(self):
        """
        threshold_set(baz_peak_detector_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.baz_peak_detector_sptr_threshold_set(self)


    def history(self):
        """history(baz_peak_detector_sptr self) -> unsigned int"""
        return _baz_swig.baz_peak_detector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_peak_detector_sptr self, int which, int delay)
        declare_sample_delay(baz_peak_detector_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_peak_detector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_peak_detector_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_peak_detector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_peak_detector_sptr self) -> int"""
        return _baz_swig.baz_peak_detector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_peak_detector_sptr self) -> double"""
        return _baz_swig.baz_peak_detector_sptr_relative_rate(self)


    def start(self):
        """start(baz_peak_detector_sptr self) -> bool"""
        return _baz_swig.baz_peak_detector_sptr_start(self)


    def stop(self):
        """stop(baz_peak_detector_sptr self) -> bool"""
        return _baz_swig.baz_peak_detector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_peak_detector_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_peak_detector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_peak_detector_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_peak_detector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_peak_detector_sptr self) -> int"""
        return _baz_swig.baz_peak_detector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_peak_detector_sptr self, int m)"""
        return _baz_swig.baz_peak_detector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_peak_detector_sptr self)"""
        return _baz_swig.baz_peak_detector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_peak_detector_sptr self) -> bool"""
        return _baz_swig.baz_peak_detector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_peak_detector_sptr self, int m)"""
        return _baz_swig.baz_peak_detector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_peak_detector_sptr self) -> int"""
        return _baz_swig.baz_peak_detector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_peak_detector_sptr self, int i) -> long"""
        return _baz_swig.baz_peak_detector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_peak_detector_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_peak_detector_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_peak_detector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_peak_detector_sptr self, int i) -> long"""
        return _baz_swig.baz_peak_detector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_peak_detector_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_peak_detector_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_peak_detector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_peak_detector_sptr self, int which) -> float
        pc_input_buffers_full(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_peak_detector_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_peak_detector_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_peak_detector_sptr self, int which) -> float
        pc_output_buffers_full(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_peak_detector_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_peak_detector_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_peak_detector_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_peak_detector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_peak_detector_sptr self) -> float"""
        return _baz_swig.baz_peak_detector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_peak_detector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_peak_detector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_peak_detector_sptr self)"""
        return _baz_swig.baz_peak_detector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_peak_detector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_peak_detector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_peak_detector_sptr self) -> int"""
        return _baz_swig.baz_peak_detector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_peak_detector_sptr self) -> int"""
        return _baz_swig.baz_peak_detector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_peak_detector_sptr self, int priority) -> int"""
        return _baz_swig.baz_peak_detector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_peak_detector_sptr self) -> std::string"""
        return _baz_swig.baz_peak_detector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_peak_detector_sptr self) -> std::string"""
        return _baz_swig.baz_peak_detector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_peak_detector_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_peak_detector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_peak_detector_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_peak_detector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_peak_detector_sptr self) -> long"""
        return _baz_swig.baz_peak_detector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_peak_detector_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_peak_detector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_peak_detector_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_peak_detector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_peak_detector_sptr self) -> std::string"""
        return _baz_swig.baz_peak_detector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_peak_detector_sptr self, std::string name)"""
        return _baz_swig.baz_peak_detector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_peak_detector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_peak_detector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_peak_detector_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_peak_detector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_peak_detector_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_peak_detector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_peak_detector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_peak_detector_sptr_message_subscribers(self, which_port)

baz_peak_detector_sptr_swigregister = _baz_swig.baz_peak_detector_sptr_swigregister
baz_peak_detector_sptr_swigregister(baz_peak_detector_sptr)


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


def peak_detector(min_diff=0.0, min_len=1, lockout=0, drop=0.0, alpha=1.0, look_ahead=0, byte_output=False, verbose=False):
    """
    peak_detector(float min_diff=0.0, int min_len=1, int lockout=0, float drop=0.0, float alpha=1.0, int look_ahead=0, bool byte_output=False, bool verbose=False) -> baz_peak_detector_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_peak_detector.

    To avoid accidental use of raw pointers, baz_peak_detector's constructor is private. howto_make_square2_ff is the public interface for creating new instances.

    Params: (min_diff, min_len, lockout, drop, alpha, look_ahead, byte_output, verbose)
    """
    return _baz_swig.peak_detector(min_diff, min_len, lockout, drop, alpha, look_ahead, byte_output, verbose)
class burst_tagger(object):
    """Proxy of C++ gr::baz::burst_tagger 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(std::string const & tag_name, float mult=1.0, unsigned int pad_front=0, unsigned int pad_rear=0, bool drop_residue=True, bool verbose=True) -> burst_tagger_sptr



        Params: (tag_name, mult, pad_front, pad_rear, drop_residue, verbose)
        """
        return _baz_swig.burst_tagger_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _baz_swig.delete_burst_tagger
    __del__ = lambda self: None
burst_tagger_swigregister = _baz_swig.burst_tagger_swigregister
burst_tagger_swigregister(burst_tagger)

def burst_tagger_make(*args, **kwargs):
    """
    burst_tagger_make(std::string const & tag_name, float mult=1.0, unsigned int pad_front=0, unsigned int pad_rear=0, bool drop_residue=True, bool verbose=True) -> burst_tagger_sptr



    Params: (tag_name, mult, pad_front, pad_rear, drop_residue, verbose)
    """
    return _baz_swig.burst_tagger_make(*args, **kwargs)

class burst_tagger_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::burst_tagger)> class."""

    thisown = _swig_property(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::baz::burst_tagger)> self) -> burst_tagger_sptr
        __init__(boost::shared_ptr<(gr::baz::burst_tagger)> self, burst_tagger p) -> burst_tagger_sptr
        """
        this = _baz_swig.new_burst_tagger_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(burst_tagger_sptr self) -> burst_tagger"""
        return _baz_swig.burst_tagger_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_burst_tagger_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(burst_tagger_sptr self, std::string const & tag_name, float mult=1.0, unsigned int pad_front=0, unsigned int pad_rear=0, bool drop_residue=True, bool verbose=True) -> burst_tagger_sptr



        Params: (tag_name, mult, pad_front, pad_rear, drop_residue, verbose)
        """
        return _baz_swig.burst_tagger_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(burst_tagger_sptr self) -> unsigned int"""
        return _baz_swig.burst_tagger_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(burst_tagger_sptr self, int which, int delay)
        declare_sample_delay(burst_tagger_sptr self, unsigned int delay)
        """
        return _baz_swig.burst_tagger_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(burst_tagger_sptr self, int which) -> unsigned int"""
        return _baz_swig.burst_tagger_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(burst_tagger_sptr self) -> int"""
        return _baz_swig.burst_tagger_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(burst_tagger_sptr self) -> double"""
        return _baz_swig.burst_tagger_sptr_relative_rate(self)


    def start(self):
        """start(burst_tagger_sptr self) -> bool"""
        return _baz_swig.burst_tagger_sptr_start(self)


    def stop(self):
        """stop(burst_tagger_sptr self) -> bool"""
        return _baz_swig.burst_tagger_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(burst_tagger_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.burst_tagger_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(burst_tagger_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.burst_tagger_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(burst_tagger_sptr self) -> int"""
        return _baz_swig.burst_tagger_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(burst_tagger_sptr self, int m)"""
        return _baz_swig.burst_tagger_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(burst_tagger_sptr self)"""
        return _baz_swig.burst_tagger_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(burst_tagger_sptr self) -> bool"""
        return _baz_swig.burst_tagger_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(burst_tagger_sptr self, int m)"""
        return _baz_swig.burst_tagger_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(burst_tagger_sptr self) -> int"""
        return _baz_swig.burst_tagger_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(burst_tagger_sptr self, int i) -> long"""
        return _baz_swig.burst_tagger_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(burst_tagger_sptr self, long max_output_buffer)
        set_max_output_buffer(burst_tagger_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.burst_tagger_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(burst_tagger_sptr self, int i) -> long"""
        return _baz_swig.burst_tagger_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(burst_tagger_sptr self, long min_output_buffer)
        set_min_output_buffer(burst_tagger_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.burst_tagger_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(burst_tagger_sptr self, int which) -> float
        pc_input_buffers_full(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(burst_tagger_sptr self, int which) -> float
        pc_input_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(burst_tagger_sptr self, int which) -> float
        pc_input_buffers_full_var(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(burst_tagger_sptr self, int which) -> float
        pc_output_buffers_full(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(burst_tagger_sptr self, int which) -> float
        pc_output_buffers_full_avg(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(burst_tagger_sptr self, int which) -> float
        pc_output_buffers_full_var(burst_tagger_sptr self) -> pmt_vector_float
        """
        return _baz_swig.burst_tagger_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(burst_tagger_sptr self) -> float"""
        return _baz_swig.burst_tagger_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(burst_tagger_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.burst_tagger_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(burst_tagger_sptr self)"""
        return _baz_swig.burst_tagger_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(burst_tagger_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.burst_tagger_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(burst_tagger_sptr self) -> int"""
        return _baz_swig.burst_tagger_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(burst_tagger_sptr self) -> int"""
        return _baz_swig.burst_tagger_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(burst_tagger_sptr self, int priority) -> int"""
        return _baz_swig.burst_tagger_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(burst_tagger_sptr self) -> std::string"""
        return _baz_swig.burst_tagger_sptr_name(self)


    def symbol_name(self):
        """symbol_name(burst_tagger_sptr self) -> std::string"""
        return _baz_swig.burst_tagger_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(burst_tagger_sptr self) -> io_signature_sptr"""
        return _baz_swig.burst_tagger_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(burst_tagger_sptr self) -> io_signature_sptr"""
        return _baz_swig.burst_tagger_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(burst_tagger_sptr self) -> long"""
        return _baz_swig.burst_tagger_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(burst_tagger_sptr self) -> basic_block_sptr"""
        return _baz_swig.burst_tagger_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(burst_tagger_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.burst_tagger_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(burst_tagger_sptr self) -> std::string"""
        return _baz_swig.burst_tagger_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(burst_tagger_sptr self, std::string name)"""
        return _baz_swig.burst_tagger_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(burst_tagger_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.burst_tagger_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(burst_tagger_sptr self) -> swig_int_ptr"""
        return _baz_swig.burst_tagger_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(burst_tagger_sptr self) -> swig_int_ptr"""
        return _baz_swig.burst_tagger_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(burst_tagger_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.burst_tagger_sptr_message_subscribers(self, which_port)

burst_tagger_sptr_swigregister = _baz_swig.burst_tagger_sptr_swigregister
burst_tagger_sptr_swigregister(burst_tagger_sptr)


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

class baz_burst_buffer_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_burst_buffer)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(baz_burst_buffer)> self) -> baz_burst_buffer_sptr
        __init__(boost::shared_ptr<(baz_burst_buffer)> self, baz_burst_buffer * p) -> baz_burst_buffer_sptr
        """
        this = _baz_swig.new_baz_burst_buffer_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_burst_buffer_sptr self) -> baz_burst_buffer *"""
        return _baz_swig.baz_burst_buffer_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_burst_buffer_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_burst_buffer_sptr self) -> unsigned int"""
        return _baz_swig.baz_burst_buffer_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_burst_buffer_sptr self, int which, int delay)
        declare_sample_delay(baz_burst_buffer_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_burst_buffer_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_burst_buffer_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_burst_buffer_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_burst_buffer_sptr self) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_burst_buffer_sptr self) -> double"""
        return _baz_swig.baz_burst_buffer_sptr_relative_rate(self)


    def start(self):
        """start(baz_burst_buffer_sptr self) -> bool"""
        return _baz_swig.baz_burst_buffer_sptr_start(self)


    def stop(self):
        """stop(baz_burst_buffer_sptr self) -> bool"""
        return _baz_swig.baz_burst_buffer_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_burst_buffer_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_burst_buffer_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_burst_buffer_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_burst_buffer_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_burst_buffer_sptr self) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_burst_buffer_sptr self, int m)"""
        return _baz_swig.baz_burst_buffer_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_burst_buffer_sptr self)"""
        return _baz_swig.baz_burst_buffer_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_burst_buffer_sptr self) -> bool"""
        return _baz_swig.baz_burst_buffer_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_burst_buffer_sptr self, int m)"""
        return _baz_swig.baz_burst_buffer_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_burst_buffer_sptr self) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_burst_buffer_sptr self, int i) -> long"""
        return _baz_swig.baz_burst_buffer_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_burst_buffer_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_burst_buffer_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_burst_buffer_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_burst_buffer_sptr self, int i) -> long"""
        return _baz_swig.baz_burst_buffer_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_burst_buffer_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_burst_buffer_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_burst_buffer_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_burst_buffer_sptr self, int which) -> float
        pc_input_buffers_full(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_burst_buffer_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_burst_buffer_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_burst_buffer_sptr self, int which) -> float
        pc_output_buffers_full(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_burst_buffer_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_burst_buffer_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_burst_buffer_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_burst_buffer_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_burst_buffer_sptr self) -> float"""
        return _baz_swig.baz_burst_buffer_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_burst_buffer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_burst_buffer_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_burst_buffer_sptr self)"""
        return _baz_swig.baz_burst_buffer_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_burst_buffer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_burst_buffer_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_burst_buffer_sptr self) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_burst_buffer_sptr self) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_burst_buffer_sptr self, int priority) -> int"""
        return _baz_swig.baz_burst_buffer_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_burst_buffer_sptr self) -> std::string"""
        return _baz_swig.baz_burst_buffer_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_burst_buffer_sptr self) -> std::string"""
        return _baz_swig.baz_burst_buffer_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_burst_buffer_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_burst_buffer_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_burst_buffer_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_burst_buffer_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_burst_buffer_sptr self) -> long"""
        return _baz_swig.baz_burst_buffer_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_burst_buffer_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_burst_buffer_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_burst_buffer_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_burst_buffer_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_burst_buffer_sptr self) -> std::string"""
        return _baz_swig.baz_burst_buffer_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_burst_buffer_sptr self, std::string name)"""
        return _baz_swig.baz_burst_buffer_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_burst_buffer_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_burst_buffer_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_burst_buffer_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_burst_buffer_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_burst_buffer_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_burst_buffer_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_burst_buffer_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_burst_buffer_sptr_message_subscribers(self, which_port)

baz_burst_buffer_sptr_swigregister = _baz_swig.baz_burst_buffer_sptr_swigregister
baz_burst_buffer_sptr_swigregister(baz_burst_buffer_sptr)


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


def burst_buffer(*args, **kwargs):
    """
    burst_buffer(int itemsize, int flush_length=0, std::string const & length_tag_name, bool verbose=False, bool only_burst=False, bool strip_tags=True) -> baz_burst_buffer_sptr

    buffer bursts

    Params: (itemsize, flush_length, length_tag_name, verbose, only_burst, strip_tags)
    """
    return _baz_swig.burst_buffer(*args, **kwargs)
class additive_scrambler_bb(object):
    """
    Scramble an input stream using an LFSR.

    This block scrambles up to 8 bits per byte of the input data stream, starting at the LSB.


    The scrambler works by XORing the incoming bit stream by the output of the LFSR. Optionally, after  bits have been processed, the shift register is reset to the  value. This allows processing fixed length vectors of samples.


    Alternatively, the LFSR can be reset using a reset tag to scramble variable length vectors. However, it cannot be reset between bytes.


    For details on configuring the LFSR, see gr::digital::lfsr.
    """

    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 mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key) -> additive_scrambler_bb_sptr

        Create additive scrambler.

        Params: (mask, seed, len, count, bits_per_byte, reset_tag_key)
        """
        return _baz_swig.additive_scrambler_bb_make(*args, **kwargs)

    make = staticmethod(make)

    def mask(self):
        """
        mask(additive_scrambler_bb self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_mask(self)


    def seed(self):
        """
        seed(additive_scrambler_bb self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_seed(self)


    def len(self):
        """
        len(additive_scrambler_bb self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_len(self)


    def count(self):
        """
        count(additive_scrambler_bb self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_count(self)


    def bits_per_byte(self):
        """
        bits_per_byte(additive_scrambler_bb self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_bits_per_byte(self)

    __swig_destroy__ = _baz_swig.delete_additive_scrambler_bb
    __del__ = lambda self: None
additive_scrambler_bb_swigregister = _baz_swig.additive_scrambler_bb_swigregister
additive_scrambler_bb_swigregister(additive_scrambler_bb)

def additive_scrambler_bb_make(*args, **kwargs):
    """
    additive_scrambler_bb_make(int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key) -> additive_scrambler_bb_sptr

    Create additive scrambler.

    Params: (mask, seed, len, count, bits_per_byte, reset_tag_key)
    """
    return _baz_swig.additive_scrambler_bb_make(*args, **kwargs)

class additive_scrambler_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::additive_scrambler_bb)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::baz::additive_scrambler_bb)> self) -> additive_scrambler_bb_sptr
        __init__(boost::shared_ptr<(gr::baz::additive_scrambler_bb)> self, additive_scrambler_bb p) -> additive_scrambler_bb_sptr
        """
        this = _baz_swig.new_additive_scrambler_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(additive_scrambler_bb_sptr self) -> additive_scrambler_bb"""
        return _baz_swig.additive_scrambler_bb_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_additive_scrambler_bb_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(additive_scrambler_bb_sptr self, int mask, int seed, int len, int count=0, int bits_per_byte=1, std::string const & reset_tag_key) -> additive_scrambler_bb_sptr

        Create additive scrambler.

        Params: (mask, seed, len, count, bits_per_byte, reset_tag_key)
        """
        return _baz_swig.additive_scrambler_bb_sptr_make(self, *args, **kwargs)


    def mask(self):
        """
        mask(additive_scrambler_bb_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_sptr_mask(self)


    def seed(self):
        """
        seed(additive_scrambler_bb_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_sptr_seed(self)


    def len(self):
        """
        len(additive_scrambler_bb_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_sptr_len(self)


    def count(self):
        """
        count(additive_scrambler_bb_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_sptr_count(self)


    def bits_per_byte(self):
        """
        bits_per_byte(additive_scrambler_bb_sptr self) -> int



        Params: (NONE)
        """
        return _baz_swig.additive_scrambler_bb_sptr_bits_per_byte(self)


    def history(self):
        """history(additive_scrambler_bb_sptr self) -> unsigned int"""
        return _baz_swig.additive_scrambler_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(additive_scrambler_bb_sptr self, int which, int delay)
        declare_sample_delay(additive_scrambler_bb_sptr self, unsigned int delay)
        """
        return _baz_swig.additive_scrambler_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(additive_scrambler_bb_sptr self, int which) -> unsigned int"""
        return _baz_swig.additive_scrambler_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(additive_scrambler_bb_sptr self) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(additive_scrambler_bb_sptr self) -> double"""
        return _baz_swig.additive_scrambler_bb_sptr_relative_rate(self)


    def start(self):
        """start(additive_scrambler_bb_sptr self) -> bool"""
        return _baz_swig.additive_scrambler_bb_sptr_start(self)


    def stop(self):
        """stop(additive_scrambler_bb_sptr self) -> bool"""
        return _baz_swig.additive_scrambler_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(additive_scrambler_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.additive_scrambler_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(additive_scrambler_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.additive_scrambler_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(additive_scrambler_bb_sptr self) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _baz_swig.additive_scrambler_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(additive_scrambler_bb_sptr self)"""
        return _baz_swig.additive_scrambler_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(additive_scrambler_bb_sptr self) -> bool"""
        return _baz_swig.additive_scrambler_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(additive_scrambler_bb_sptr self, int m)"""
        return _baz_swig.additive_scrambler_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(additive_scrambler_bb_sptr self) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(additive_scrambler_bb_sptr self, int i) -> long"""
        return _baz_swig.additive_scrambler_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(additive_scrambler_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(additive_scrambler_bb_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.additive_scrambler_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(additive_scrambler_bb_sptr self, int i) -> long"""
        return _baz_swig.additive_scrambler_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(additive_scrambler_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(additive_scrambler_bb_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.additive_scrambler_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(additive_scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(additive_scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(additive_scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.additive_scrambler_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(additive_scrambler_bb_sptr self) -> float"""
        return _baz_swig.additive_scrambler_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(additive_scrambler_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.additive_scrambler_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(additive_scrambler_bb_sptr self)"""
        return _baz_swig.additive_scrambler_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(additive_scrambler_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.additive_scrambler_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(additive_scrambler_bb_sptr self) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(additive_scrambler_bb_sptr self) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(additive_scrambler_bb_sptr self, int priority) -> int"""
        return _baz_swig.additive_scrambler_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(additive_scrambler_bb_sptr self) -> std::string"""
        return _baz_swig.additive_scrambler_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(additive_scrambler_bb_sptr self) -> std::string"""
        return _baz_swig.additive_scrambler_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.additive_scrambler_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(additive_scrambler_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.additive_scrambler_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(additive_scrambler_bb_sptr self) -> long"""
        return _baz_swig.additive_scrambler_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(additive_scrambler_bb_sptr self) -> basic_block_sptr"""
        return _baz_swig.additive_scrambler_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(additive_scrambler_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.additive_scrambler_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(additive_scrambler_bb_sptr self) -> std::string"""
        return _baz_swig.additive_scrambler_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(additive_scrambler_bb_sptr self, std::string name)"""
        return _baz_swig.additive_scrambler_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(additive_scrambler_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.additive_scrambler_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(additive_scrambler_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.additive_scrambler_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(additive_scrambler_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.additive_scrambler_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(additive_scrambler_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.additive_scrambler_bb_sptr_message_subscribers(self, which_port)

additive_scrambler_bb_sptr_swigregister = _baz_swig.additive_scrambler_bb_sptr_swigregister
additive_scrambler_bb_sptr_swigregister(additive_scrambler_bb_sptr)


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

class baz_correlator_sptr(object):
    """Proxy of C++ boost::shared_ptr<(baz_correlator)> class."""

    thisown = _swig_property(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<(baz_correlator)> self) -> baz_correlator_sptr
        __init__(boost::shared_ptr<(baz_correlator)> self, baz_correlator * p) -> baz_correlator_sptr
        """
        this = _baz_swig.new_baz_correlator_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(baz_correlator_sptr self) -> baz_correlator *"""
        return _baz_swig.baz_correlator_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_baz_correlator_sptr
    __del__ = lambda self: None

    def history(self):
        """history(baz_correlator_sptr self) -> unsigned int"""
        return _baz_swig.baz_correlator_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(baz_correlator_sptr self, int which, int delay)
        declare_sample_delay(baz_correlator_sptr self, unsigned int delay)
        """
        return _baz_swig.baz_correlator_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(baz_correlator_sptr self, int which) -> unsigned int"""
        return _baz_swig.baz_correlator_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(baz_correlator_sptr self) -> int"""
        return _baz_swig.baz_correlator_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(baz_correlator_sptr self) -> double"""
        return _baz_swig.baz_correlator_sptr_relative_rate(self)


    def start(self):
        """start(baz_correlator_sptr self) -> bool"""
        return _baz_swig.baz_correlator_sptr_start(self)


    def stop(self):
        """stop(baz_correlator_sptr self) -> bool"""
        return _baz_swig.baz_correlator_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(baz_correlator_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.baz_correlator_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(baz_correlator_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.baz_correlator_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(baz_correlator_sptr self) -> int"""
        return _baz_swig.baz_correlator_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(baz_correlator_sptr self, int m)"""
        return _baz_swig.baz_correlator_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(baz_correlator_sptr self)"""
        return _baz_swig.baz_correlator_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(baz_correlator_sptr self) -> bool"""
        return _baz_swig.baz_correlator_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(baz_correlator_sptr self, int m)"""
        return _baz_swig.baz_correlator_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(baz_correlator_sptr self) -> int"""
        return _baz_swig.baz_correlator_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(baz_correlator_sptr self, int i) -> long"""
        return _baz_swig.baz_correlator_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(baz_correlator_sptr self, long max_output_buffer)
        set_max_output_buffer(baz_correlator_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.baz_correlator_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(baz_correlator_sptr self, int i) -> long"""
        return _baz_swig.baz_correlator_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(baz_correlator_sptr self, long min_output_buffer)
        set_min_output_buffer(baz_correlator_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.baz_correlator_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(baz_correlator_sptr self, int which) -> float
        pc_input_buffers_full(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(baz_correlator_sptr self, int which) -> float
        pc_input_buffers_full_avg(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(baz_correlator_sptr self, int which) -> float
        pc_input_buffers_full_var(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(baz_correlator_sptr self, int which) -> float
        pc_output_buffers_full(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(baz_correlator_sptr self, int which) -> float
        pc_output_buffers_full_avg(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(baz_correlator_sptr self, int which) -> float
        pc_output_buffers_full_var(baz_correlator_sptr self) -> pmt_vector_float
        """
        return _baz_swig.baz_correlator_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(baz_correlator_sptr self) -> float"""
        return _baz_swig.baz_correlator_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(baz_correlator_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.baz_correlator_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(baz_correlator_sptr self)"""
        return _baz_swig.baz_correlator_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(baz_correlator_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.baz_correlator_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(baz_correlator_sptr self) -> int"""
        return _baz_swig.baz_correlator_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(baz_correlator_sptr self) -> int"""
        return _baz_swig.baz_correlator_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(baz_correlator_sptr self, int priority) -> int"""
        return _baz_swig.baz_correlator_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(baz_correlator_sptr self) -> std::string"""
        return _baz_swig.baz_correlator_sptr_name(self)


    def symbol_name(self):
        """symbol_name(baz_correlator_sptr self) -> std::string"""
        return _baz_swig.baz_correlator_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(baz_correlator_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_correlator_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(baz_correlator_sptr self) -> io_signature_sptr"""
        return _baz_swig.baz_correlator_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(baz_correlator_sptr self) -> long"""
        return _baz_swig.baz_correlator_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(baz_correlator_sptr self) -> basic_block_sptr"""
        return _baz_swig.baz_correlator_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(baz_correlator_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.baz_correlator_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(baz_correlator_sptr self) -> std::string"""
        return _baz_swig.baz_correlator_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(baz_correlator_sptr self, std::string name)"""
        return _baz_swig.baz_correlator_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(baz_correlator_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.baz_correlator_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(baz_correlator_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_correlator_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(baz_correlator_sptr self) -> swig_int_ptr"""
        return _baz_swig.baz_correlator_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(baz_correlator_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.baz_correlator_sptr_message_subscribers(self, which_port)

baz_correlator_sptr_swigregister = _baz_swig.baz_correlator_sptr_swigregister
baz_correlator_sptr_swigregister(baz_correlator_sptr)


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


def correlator(*args, **kwargs):
    """
    correlator(float samp_rate, float symbol_rate, int window_length, float threshold=0.5, int width=1024, char const * sync_path, int sync_length=511, int sync_offset=50, int sync_window_length=50) -> baz_correlator_sptr

    square2 a stream of floats.

    This uses the preferred technique: subclassing gr::sync_block.

    Return a shared_ptr to a new instance of baz_correlator.

    To avoid accidental use of raw pointers, baz_correlator's constructor is private. baz_make_correlator is the public interface for creating new instances.

    Params: (samp_rate, symbol_rate, window_length, threshold, width, sync_path, sync_length, sync_offset, sync_window_length)
    """
    return _baz_swig.correlator(*args, **kwargs)
class dpll_bb(object):
    """
    Detect the peak of a signal.

    If a peak is detected, this block outputs a 1, or it outputs 0's.
    """

    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(float period, float gain, float relative_limit=1.0, float ignore_limit=1.0, std::string const length_tag, bool verbose=False, bool unlocked=False) -> dpll_bb_sptr



        Params: (period, gain, relative_limit, ignore_limit, length_tag, verbose, unlocked)
        """
        return _baz_swig.dpll_bb_make(*args, **kwargs)

    make = staticmethod(make)

    def set_gain(self, gain):
        """
        set_gain(dpll_bb self, float gain)



        Params: (gain)
        """
        return _baz_swig.dpll_bb_set_gain(self, gain)


    def set_decision_threshold(self, thresh):
        """
        set_decision_threshold(dpll_bb self, float thresh)



        Params: (thresh)
        """
        return _baz_swig.dpll_bb_set_decision_threshold(self, thresh)


    def gain(self):
        """
        gain(dpll_bb self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_gain(self)


    def freq(self):
        """
        freq(dpll_bb self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_freq(self)


    def phase(self):
        """
        phase(dpll_bb self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_phase(self)


    def decision_threshold(self):
        """
        decision_threshold(dpll_bb self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_decision_threshold(self)

    __swig_destroy__ = _baz_swig.delete_dpll_bb
    __del__ = lambda self: None
dpll_bb_swigregister = _baz_swig.dpll_bb_swigregister
dpll_bb_swigregister(dpll_bb)

def dpll_bb_make(*args, **kwargs):
    """
    dpll_bb_make(float period, float gain, float relative_limit=1.0, float ignore_limit=1.0, std::string const length_tag, bool verbose=False, bool unlocked=False) -> dpll_bb_sptr



    Params: (period, gain, relative_limit, ignore_limit, length_tag, verbose, unlocked)
    """
    return _baz_swig.dpll_bb_make(*args, **kwargs)

class dpll_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::dpll_bb)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::baz::dpll_bb)> self) -> dpll_bb_sptr
        __init__(boost::shared_ptr<(gr::baz::dpll_bb)> self, dpll_bb p) -> dpll_bb_sptr
        """
        this = _baz_swig.new_dpll_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(dpll_bb_sptr self) -> dpll_bb"""
        return _baz_swig.dpll_bb_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_dpll_bb_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(dpll_bb_sptr self, float period, float gain, float relative_limit=1.0, float ignore_limit=1.0, std::string const length_tag, bool verbose=False, bool unlocked=False) -> dpll_bb_sptr



        Params: (period, gain, relative_limit, ignore_limit, length_tag, verbose, unlocked)
        """
        return _baz_swig.dpll_bb_sptr_make(self, *args, **kwargs)


    def set_gain(self, gain):
        """
        set_gain(dpll_bb_sptr self, float gain)



        Params: (gain)
        """
        return _baz_swig.dpll_bb_sptr_set_gain(self, gain)


    def set_decision_threshold(self, thresh):
        """
        set_decision_threshold(dpll_bb_sptr self, float thresh)



        Params: (thresh)
        """
        return _baz_swig.dpll_bb_sptr_set_decision_threshold(self, thresh)


    def gain(self):
        """
        gain(dpll_bb_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_sptr_gain(self)


    def freq(self):
        """
        freq(dpll_bb_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_sptr_freq(self)


    def phase(self):
        """
        phase(dpll_bb_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_sptr_phase(self)


    def decision_threshold(self):
        """
        decision_threshold(dpll_bb_sptr self) -> float



        Params: (NONE)
        """
        return _baz_swig.dpll_bb_sptr_decision_threshold(self)


    def history(self):
        """history(dpll_bb_sptr self) -> unsigned int"""
        return _baz_swig.dpll_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(dpll_bb_sptr self, int which, int delay)
        declare_sample_delay(dpll_bb_sptr self, unsigned int delay)
        """
        return _baz_swig.dpll_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(dpll_bb_sptr self, int which) -> unsigned int"""
        return _baz_swig.dpll_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(dpll_bb_sptr self) -> int"""
        return _baz_swig.dpll_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(dpll_bb_sptr self) -> double"""
        return _baz_swig.dpll_bb_sptr_relative_rate(self)


    def start(self):
        """start(dpll_bb_sptr self) -> bool"""
        return _baz_swig.dpll_bb_sptr_start(self)


    def stop(self):
        """stop(dpll_bb_sptr self) -> bool"""
        return _baz_swig.dpll_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(dpll_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.dpll_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(dpll_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.dpll_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(dpll_bb_sptr self) -> int"""
        return _baz_swig.dpll_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(dpll_bb_sptr self, int m)"""
        return _baz_swig.dpll_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(dpll_bb_sptr self)"""
        return _baz_swig.dpll_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(dpll_bb_sptr self) -> bool"""
        return _baz_swig.dpll_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(dpll_bb_sptr self, int m)"""
        return _baz_swig.dpll_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(dpll_bb_sptr self) -> int"""
        return _baz_swig.dpll_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(dpll_bb_sptr self, int i) -> long"""
        return _baz_swig.dpll_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(dpll_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(dpll_bb_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.dpll_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(dpll_bb_sptr self, int i) -> long"""
        return _baz_swig.dpll_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(dpll_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(dpll_bb_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.dpll_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(dpll_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(dpll_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(dpll_bb_sptr self) -> pmt_vector_float
        """
        return _baz_swig.dpll_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(dpll_bb_sptr self) -> float"""
        return _baz_swig.dpll_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(dpll_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.dpll_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(dpll_bb_sptr self)"""
        return _baz_swig.dpll_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(dpll_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.dpll_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(dpll_bb_sptr self) -> int"""
        return _baz_swig.dpll_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(dpll_bb_sptr self) -> int"""
        return _baz_swig.dpll_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(dpll_bb_sptr self, int priority) -> int"""
        return _baz_swig.dpll_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(dpll_bb_sptr self) -> std::string"""
        return _baz_swig.dpll_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(dpll_bb_sptr self) -> std::string"""
        return _baz_swig.dpll_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.dpll_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(dpll_bb_sptr self) -> io_signature_sptr"""
        return _baz_swig.dpll_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(dpll_bb_sptr self) -> long"""
        return _baz_swig.dpll_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(dpll_bb_sptr self) -> basic_block_sptr"""
        return _baz_swig.dpll_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(dpll_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.dpll_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(dpll_bb_sptr self) -> std::string"""
        return _baz_swig.dpll_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(dpll_bb_sptr self, std::string name)"""
        return _baz_swig.dpll_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(dpll_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.dpll_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(dpll_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.dpll_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(dpll_bb_sptr self) -> swig_int_ptr"""
        return _baz_swig.dpll_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(dpll_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.dpll_bb_sptr_message_subscribers(self, which_port)

dpll_bb_sptr_swigregister = _baz_swig.dpll_bb_sptr_swigregister
dpll_bb_sptr_swigregister(dpll_bb_sptr)


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

class fractional_resampler_cc(object):
    """resampling MMSE filter with complex input, complex output"""

    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(phase_shift, resamp_ratio, resamp_ratio_num=0, resamp_ratio_denom=0):
        """
        make(double phase_shift, double resamp_ratio, unsigned long long resamp_ratio_num=0, unsigned long long resamp_ratio_denom=0) -> fractional_resampler_cc_sptr

        Build the resampling MMSE filter (complex input, complex output)

        Params: (phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)
        """
        return _baz_swig.fractional_resampler_cc_make(phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)

    make = staticmethod(make)

    def mu(self):
        """
        mu(fractional_resampler_cc self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_cc_mu(self)


    def resamp_ratio(self):
        """
        resamp_ratio(fractional_resampler_cc self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_cc_resamp_ratio(self)


    def set_mu(self, mu):
        """
        set_mu(fractional_resampler_cc self, long double mu)



        Params: (mu)
        """
        return _baz_swig.fractional_resampler_cc_set_mu(self, mu)


    def set_resamp_ratio(self, *args):
        """
        set_resamp_ratio(fractional_resampler_cc self, long double resamp_ratio)
        set_resamp_ratio(fractional_resampler_cc self, double resamp_ratio)
        set_resamp_ratio(fractional_resampler_cc self, unsigned long long resamp_ratio_num, unsigned long long resamp_ratio_denom)



        Params: (resamp_ratio)
        """
        return _baz_swig.fractional_resampler_cc_set_resamp_ratio(self, *args)

    __swig_destroy__ = _baz_swig.delete_fractional_resampler_cc
    __del__ = lambda self: None
fractional_resampler_cc_swigregister = _baz_swig.fractional_resampler_cc_swigregister
fractional_resampler_cc_swigregister(fractional_resampler_cc)

def fractional_resampler_cc_make(phase_shift, resamp_ratio, resamp_ratio_num=0, resamp_ratio_denom=0):
    """
    fractional_resampler_cc_make(double phase_shift, double resamp_ratio, unsigned long long resamp_ratio_num=0, unsigned long long resamp_ratio_denom=0) -> fractional_resampler_cc_sptr

    Build the resampling MMSE filter (complex input, complex output)

    Params: (phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)
    """
    return _baz_swig.fractional_resampler_cc_make(phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)

class fractional_resampler_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::fractional_resampler_cc)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::baz::fractional_resampler_cc)> self) -> fractional_resampler_cc_sptr
        __init__(boost::shared_ptr<(gr::baz::fractional_resampler_cc)> self, fractional_resampler_cc p) -> fractional_resampler_cc_sptr
        """
        this = _baz_swig.new_fractional_resampler_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(fractional_resampler_cc_sptr self) -> fractional_resampler_cc"""
        return _baz_swig.fractional_resampler_cc_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_fractional_resampler_cc_sptr
    __del__ = lambda self: None

    def make(self, phase_shift, resamp_ratio, resamp_ratio_num=0, resamp_ratio_denom=0):
        """
        make(fractional_resampler_cc_sptr self, double phase_shift, double resamp_ratio, unsigned long long resamp_ratio_num=0, unsigned long long resamp_ratio_denom=0) -> fractional_resampler_cc_sptr

        Build the resampling MMSE filter (complex input, complex output)

        Params: (phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)
        """
        return _baz_swig.fractional_resampler_cc_sptr_make(self, phase_shift, resamp_ratio, resamp_ratio_num, resamp_ratio_denom)


    def mu(self):
        """
        mu(fractional_resampler_cc_sptr self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_cc_sptr_mu(self)


    def resamp_ratio(self):
        """
        resamp_ratio(fractional_resampler_cc_sptr self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_cc_sptr_resamp_ratio(self)


    def set_mu(self, mu):
        """
        set_mu(fractional_resampler_cc_sptr self, long double mu)



        Params: (mu)
        """
        return _baz_swig.fractional_resampler_cc_sptr_set_mu(self, mu)


    def set_resamp_ratio(self, *args):
        """
        set_resamp_ratio(fractional_resampler_cc_sptr self, long double resamp_ratio)
        set_resamp_ratio(fractional_resampler_cc_sptr self, double resamp_ratio)
        set_resamp_ratio(fractional_resampler_cc_sptr self, unsigned long long resamp_ratio_num, unsigned long long resamp_ratio_denom)



        Params: (resamp_ratio)
        """
        return _baz_swig.fractional_resampler_cc_sptr_set_resamp_ratio(self, *args)


    def history(self):
        """history(fractional_resampler_cc_sptr self) -> unsigned int"""
        return _baz_swig.fractional_resampler_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(fractional_resampler_cc_sptr self, int which, int delay)
        declare_sample_delay(fractional_resampler_cc_sptr self, unsigned int delay)
        """
        return _baz_swig.fractional_resampler_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(fractional_resampler_cc_sptr self, int which) -> unsigned int"""
        return _baz_swig.fractional_resampler_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fractional_resampler_cc_sptr self) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fractional_resampler_cc_sptr self) -> double"""
        return _baz_swig.fractional_resampler_cc_sptr_relative_rate(self)


    def start(self):
        """start(fractional_resampler_cc_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_cc_sptr_start(self)


    def stop(self):
        """stop(fractional_resampler_cc_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(fractional_resampler_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.fractional_resampler_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(fractional_resampler_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.fractional_resampler_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(fractional_resampler_cc_sptr self) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(fractional_resampler_cc_sptr self, int m)"""
        return _baz_swig.fractional_resampler_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(fractional_resampler_cc_sptr self)"""
        return _baz_swig.fractional_resampler_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(fractional_resampler_cc_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(fractional_resampler_cc_sptr self, int m)"""
        return _baz_swig.fractional_resampler_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(fractional_resampler_cc_sptr self) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(fractional_resampler_cc_sptr self, int i) -> long"""
        return _baz_swig.fractional_resampler_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(fractional_resampler_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(fractional_resampler_cc_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.fractional_resampler_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(fractional_resampler_cc_sptr self, int i) -> long"""
        return _baz_swig.fractional_resampler_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(fractional_resampler_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(fractional_resampler_cc_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.fractional_resampler_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(fractional_resampler_cc_sptr self, int which) -> float
        pc_input_buffers_full(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(fractional_resampler_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(fractional_resampler_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(fractional_resampler_cc_sptr self, int which) -> float
        pc_output_buffers_full(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(fractional_resampler_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(fractional_resampler_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(fractional_resampler_cc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(fractional_resampler_cc_sptr self) -> float"""
        return _baz_swig.fractional_resampler_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(fractional_resampler_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.fractional_resampler_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(fractional_resampler_cc_sptr self)"""
        return _baz_swig.fractional_resampler_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(fractional_resampler_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.fractional_resampler_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(fractional_resampler_cc_sptr self) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fractional_resampler_cc_sptr self) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(fractional_resampler_cc_sptr self, int priority) -> int"""
        return _baz_swig.fractional_resampler_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(fractional_resampler_cc_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fractional_resampler_cc_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fractional_resampler_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.fractional_resampler_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fractional_resampler_cc_sptr self) -> io_signature_sptr"""
        return _baz_swig.fractional_resampler_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fractional_resampler_cc_sptr self) -> long"""
        return _baz_swig.fractional_resampler_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(fractional_resampler_cc_sptr self) -> basic_block_sptr"""
        return _baz_swig.fractional_resampler_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(fractional_resampler_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.fractional_resampler_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(fractional_resampler_cc_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(fractional_resampler_cc_sptr self, std::string name)"""
        return _baz_swig.fractional_resampler_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(fractional_resampler_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.fractional_resampler_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fractional_resampler_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fractional_resampler_cc_sptr self) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fractional_resampler_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_cc_sptr_message_subscribers(self, which_port)

fractional_resampler_cc_sptr_swigregister = _baz_swig.fractional_resampler_cc_sptr_swigregister
fractional_resampler_cc_sptr_swigregister(fractional_resampler_cc_sptr)


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

class fractional_resampler_ff(object):
    """resampling MMSE filter with complex input, complex output"""

    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(phase_shift, resamp_ratio):
        """
        make(double phase_shift, double resamp_ratio) -> fractional_resampler_ff_sptr

        Build the resampling MMSE filter (complex input, complex output)

        Params: (phase_shift, resamp_ratio)
        """
        return _baz_swig.fractional_resampler_ff_make(phase_shift, resamp_ratio)

    make = staticmethod(make)

    def mu(self):
        """
        mu(fractional_resampler_ff self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_ff_mu(self)


    def resamp_ratio(self):
        """
        resamp_ratio(fractional_resampler_ff self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_ff_resamp_ratio(self)


    def set_mu(self, mu):
        """
        set_mu(fractional_resampler_ff self, long double mu)



        Params: (mu)
        """
        return _baz_swig.fractional_resampler_ff_set_mu(self, mu)


    def set_resamp_ratio(self, *args):
        """
        set_resamp_ratio(fractional_resampler_ff self, long double resamp_ratio)
        set_resamp_ratio(fractional_resampler_ff self, double resamp_ratio)



        Params: (resamp_ratio)
        """
        return _baz_swig.fractional_resampler_ff_set_resamp_ratio(self, *args)

    __swig_destroy__ = _baz_swig.delete_fractional_resampler_ff
    __del__ = lambda self: None
fractional_resampler_ff_swigregister = _baz_swig.fractional_resampler_ff_swigregister
fractional_resampler_ff_swigregister(fractional_resampler_ff)

def fractional_resampler_ff_make(phase_shift, resamp_ratio):
    """
    fractional_resampler_ff_make(double phase_shift, double resamp_ratio) -> fractional_resampler_ff_sptr

    Build the resampling MMSE filter (complex input, complex output)

    Params: (phase_shift, resamp_ratio)
    """
    return _baz_swig.fractional_resampler_ff_make(phase_shift, resamp_ratio)

class fractional_resampler_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::fractional_resampler_ff)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::baz::fractional_resampler_ff)> self) -> fractional_resampler_ff_sptr
        __init__(boost::shared_ptr<(gr::baz::fractional_resampler_ff)> self, fractional_resampler_ff p) -> fractional_resampler_ff_sptr
        """
        this = _baz_swig.new_fractional_resampler_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(fractional_resampler_ff_sptr self) -> fractional_resampler_ff"""
        return _baz_swig.fractional_resampler_ff_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_fractional_resampler_ff_sptr
    __del__ = lambda self: None

    def make(self, phase_shift, resamp_ratio):
        """
        make(fractional_resampler_ff_sptr self, double phase_shift, double resamp_ratio) -> fractional_resampler_ff_sptr

        Build the resampling MMSE filter (complex input, complex output)

        Params: (phase_shift, resamp_ratio)
        """
        return _baz_swig.fractional_resampler_ff_sptr_make(self, phase_shift, resamp_ratio)


    def mu(self):
        """
        mu(fractional_resampler_ff_sptr self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_ff_sptr_mu(self)


    def resamp_ratio(self):
        """
        resamp_ratio(fractional_resampler_ff_sptr self) -> long double



        Params: (NONE)
        """
        return _baz_swig.fractional_resampler_ff_sptr_resamp_ratio(self)


    def set_mu(self, mu):
        """
        set_mu(fractional_resampler_ff_sptr self, long double mu)



        Params: (mu)
        """
        return _baz_swig.fractional_resampler_ff_sptr_set_mu(self, mu)


    def set_resamp_ratio(self, *args):
        """
        set_resamp_ratio(fractional_resampler_ff_sptr self, long double resamp_ratio)
        set_resamp_ratio(fractional_resampler_ff_sptr self, double resamp_ratio)



        Params: (resamp_ratio)
        """
        return _baz_swig.fractional_resampler_ff_sptr_set_resamp_ratio(self, *args)


    def history(self):
        """history(fractional_resampler_ff_sptr self) -> unsigned int"""
        return _baz_swig.fractional_resampler_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(fractional_resampler_ff_sptr self, int which, int delay)
        declare_sample_delay(fractional_resampler_ff_sptr self, unsigned int delay)
        """
        return _baz_swig.fractional_resampler_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(fractional_resampler_ff_sptr self, int which) -> unsigned int"""
        return _baz_swig.fractional_resampler_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(fractional_resampler_ff_sptr self) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(fractional_resampler_ff_sptr self) -> double"""
        return _baz_swig.fractional_resampler_ff_sptr_relative_rate(self)


    def start(self):
        """start(fractional_resampler_ff_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_ff_sptr_start(self)


    def stop(self):
        """stop(fractional_resampler_ff_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(fractional_resampler_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.fractional_resampler_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(fractional_resampler_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.fractional_resampler_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(fractional_resampler_ff_sptr self) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(fractional_resampler_ff_sptr self, int m)"""
        return _baz_swig.fractional_resampler_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(fractional_resampler_ff_sptr self)"""
        return _baz_swig.fractional_resampler_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(fractional_resampler_ff_sptr self) -> bool"""
        return _baz_swig.fractional_resampler_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(fractional_resampler_ff_sptr self, int m)"""
        return _baz_swig.fractional_resampler_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(fractional_resampler_ff_sptr self) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(fractional_resampler_ff_sptr self, int i) -> long"""
        return _baz_swig.fractional_resampler_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(fractional_resampler_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(fractional_resampler_ff_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.fractional_resampler_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(fractional_resampler_ff_sptr self, int i) -> long"""
        return _baz_swig.fractional_resampler_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(fractional_resampler_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(fractional_resampler_ff_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.fractional_resampler_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(fractional_resampler_ff_sptr self, int which) -> float
        pc_input_buffers_full(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(fractional_resampler_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(fractional_resampler_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(fractional_resampler_ff_sptr self, int which) -> float
        pc_output_buffers_full(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(fractional_resampler_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(fractional_resampler_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(fractional_resampler_ff_sptr self) -> pmt_vector_float
        """
        return _baz_swig.fractional_resampler_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(fractional_resampler_ff_sptr self) -> float"""
        return _baz_swig.fractional_resampler_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(fractional_resampler_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.fractional_resampler_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(fractional_resampler_ff_sptr self)"""
        return _baz_swig.fractional_resampler_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(fractional_resampler_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.fractional_resampler_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(fractional_resampler_ff_sptr self) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(fractional_resampler_ff_sptr self) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(fractional_resampler_ff_sptr self, int priority) -> int"""
        return _baz_swig.fractional_resampler_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(fractional_resampler_ff_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(fractional_resampler_ff_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(fractional_resampler_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.fractional_resampler_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(fractional_resampler_ff_sptr self) -> io_signature_sptr"""
        return _baz_swig.fractional_resampler_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(fractional_resampler_ff_sptr self) -> long"""
        return _baz_swig.fractional_resampler_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(fractional_resampler_ff_sptr self) -> basic_block_sptr"""
        return _baz_swig.fractional_resampler_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(fractional_resampler_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.fractional_resampler_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(fractional_resampler_ff_sptr self) -> std::string"""
        return _baz_swig.fractional_resampler_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(fractional_resampler_ff_sptr self, std::string name)"""
        return _baz_swig.fractional_resampler_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(fractional_resampler_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.fractional_resampler_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(fractional_resampler_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(fractional_resampler_ff_sptr self) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(fractional_resampler_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.fractional_resampler_ff_sptr_message_subscribers(self, which_port)

fractional_resampler_ff_sptr_swigregister = _baz_swig.fractional_resampler_ff_sptr_swigregister
fractional_resampler_ff_sptr_swigregister(fractional_resampler_ff_sptr)


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

class colouriser(object):
    """
    Detect the peak of a signal.

    If a peak is detected, this block outputs a 1, or it outputs 0's.
    """

    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(ref_lvl=1.0, dyn_rng=1.0, vlen_in=1, verbose=False):
        """
        make(float ref_lvl=1.0, float dyn_rng=1.0, int vlen_in=1, bool verbose=False) -> colouriser_sptr



        Params: (ref_lvl, dyn_rng, vlen_in, verbose)
        """
        return _baz_swig.colouriser_make(ref_lvl, dyn_rng, vlen_in, verbose)

    make = staticmethod(make)

    def set_dyn_rng(self, dyn_rng):
        """
        set_dyn_rng(colouriser self, float dyn_rng)



        Params: (dyn_rng)
        """
        return _baz_swig.colouriser_set_dyn_rng(self, dyn_rng)


    def set_ref_lvl(self, ref_lvl):
        """
        set_ref_lvl(colouriser self, float ref_lvl)



        Params: (ref_lvl)
        """
        return _baz_swig.colouriser_set_ref_lvl(self, ref_lvl)

    __swig_destroy__ = _baz_swig.delete_colouriser
    __del__ = lambda self: None
colouriser_swigregister = _baz_swig.colouriser_swigregister
colouriser_swigregister(colouriser)

def colouriser_make(ref_lvl=1.0, dyn_rng=1.0, vlen_in=1, verbose=False):
    """
    colouriser_make(float ref_lvl=1.0, float dyn_rng=1.0, int vlen_in=1, bool verbose=False) -> colouriser_sptr



    Params: (ref_lvl, dyn_rng, vlen_in, verbose)
    """
    return _baz_swig.colouriser_make(ref_lvl, dyn_rng, vlen_in, verbose)

class colouriser_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::colouriser)> class."""

    thisown = _swig_property(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::baz::colouriser)> self) -> colouriser_sptr
        __init__(boost::shared_ptr<(gr::baz::colouriser)> self, colouriser p) -> colouriser_sptr
        """
        this = _baz_swig.new_colouriser_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(colouriser_sptr self) -> colouriser"""
        return _baz_swig.colouriser_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_colouriser_sptr
    __del__ = lambda self: None

    def make(self, ref_lvl=1.0, dyn_rng=1.0, vlen_in=1, verbose=False):
        """
        make(colouriser_sptr self, float ref_lvl=1.0, float dyn_rng=1.0, int vlen_in=1, bool verbose=False) -> colouriser_sptr



        Params: (ref_lvl, dyn_rng, vlen_in, verbose)
        """
        return _baz_swig.colouriser_sptr_make(self, ref_lvl, dyn_rng, vlen_in, verbose)


    def set_dyn_rng(self, dyn_rng):
        """
        set_dyn_rng(colouriser_sptr self, float dyn_rng)



        Params: (dyn_rng)
        """
        return _baz_swig.colouriser_sptr_set_dyn_rng(self, dyn_rng)


    def set_ref_lvl(self, ref_lvl):
        """
        set_ref_lvl(colouriser_sptr self, float ref_lvl)



        Params: (ref_lvl)
        """
        return _baz_swig.colouriser_sptr_set_ref_lvl(self, ref_lvl)


    def history(self):
        """history(colouriser_sptr self) -> unsigned int"""
        return _baz_swig.colouriser_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(colouriser_sptr self, int which, int delay)
        declare_sample_delay(colouriser_sptr self, unsigned int delay)
        """
        return _baz_swig.colouriser_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(colouriser_sptr self, int which) -> unsigned int"""
        return _baz_swig.colouriser_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(colouriser_sptr self) -> int"""
        return _baz_swig.colouriser_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(colouriser_sptr self) -> double"""
        return _baz_swig.colouriser_sptr_relative_rate(self)


    def start(self):
        """start(colouriser_sptr self) -> bool"""
        return _baz_swig.colouriser_sptr_start(self)


    def stop(self):
        """stop(colouriser_sptr self) -> bool"""
        return _baz_swig.colouriser_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(colouriser_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.colouriser_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(colouriser_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.colouriser_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(colouriser_sptr self) -> int"""
        return _baz_swig.colouriser_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(colouriser_sptr self, int m)"""
        return _baz_swig.colouriser_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(colouriser_sptr self)"""
        return _baz_swig.colouriser_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(colouriser_sptr self) -> bool"""
        return _baz_swig.colouriser_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(colouriser_sptr self, int m)"""
        return _baz_swig.colouriser_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(colouriser_sptr self) -> int"""
        return _baz_swig.colouriser_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(colouriser_sptr self, int i) -> long"""
        return _baz_swig.colouriser_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(colouriser_sptr self, long max_output_buffer)
        set_max_output_buffer(colouriser_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.colouriser_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(colouriser_sptr self, int i) -> long"""
        return _baz_swig.colouriser_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(colouriser_sptr self, long min_output_buffer)
        set_min_output_buffer(colouriser_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.colouriser_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(colouriser_sptr self, int which) -> float
        pc_input_buffers_full(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(colouriser_sptr self, int which) -> float
        pc_input_buffers_full_avg(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(colouriser_sptr self, int which) -> float
        pc_input_buffers_full_var(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(colouriser_sptr self, int which) -> float
        pc_output_buffers_full(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(colouriser_sptr self, int which) -> float
        pc_output_buffers_full_avg(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(colouriser_sptr self, int which) -> float
        pc_output_buffers_full_var(colouriser_sptr self) -> pmt_vector_float
        """
        return _baz_swig.colouriser_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(colouriser_sptr self) -> float"""
        return _baz_swig.colouriser_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(colouriser_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.colouriser_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(colouriser_sptr self)"""
        return _baz_swig.colouriser_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(colouriser_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.colouriser_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(colouriser_sptr self) -> int"""
        return _baz_swig.colouriser_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(colouriser_sptr self) -> int"""
        return _baz_swig.colouriser_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(colouriser_sptr self, int priority) -> int"""
        return _baz_swig.colouriser_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(colouriser_sptr self) -> std::string"""
        return _baz_swig.colouriser_sptr_name(self)


    def symbol_name(self):
        """symbol_name(colouriser_sptr self) -> std::string"""
        return _baz_swig.colouriser_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(colouriser_sptr self) -> io_signature_sptr"""
        return _baz_swig.colouriser_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(colouriser_sptr self) -> io_signature_sptr"""
        return _baz_swig.colouriser_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(colouriser_sptr self) -> long"""
        return _baz_swig.colouriser_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(colouriser_sptr self) -> basic_block_sptr"""
        return _baz_swig.colouriser_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(colouriser_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.colouriser_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(colouriser_sptr self) -> std::string"""
        return _baz_swig.colouriser_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(colouriser_sptr self, std::string name)"""
        return _baz_swig.colouriser_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(colouriser_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.colouriser_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(colouriser_sptr self) -> swig_int_ptr"""
        return _baz_swig.colouriser_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(colouriser_sptr self) -> swig_int_ptr"""
        return _baz_swig.colouriser_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(colouriser_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.colouriser_sptr_message_subscribers(self, which_port)

colouriser_sptr_swigregister = _baz_swig.colouriser_sptr_swigregister
colouriser_sptr_swigregister(colouriser_sptr)


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

class swap(object):
    """
    Detect the peak of a signal.

    If a peak is detected, this block outputs a 1, or it outputs 0's.
    """

    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(item_size, vlen, swap=True):
        """
        make(int item_size, int vlen, bool swap=True) -> swap_sptr



        Params: (item_size, vlen, swap)
        """
        return _baz_swig.swap_make(item_size, vlen, swap)

    make = staticmethod(make)

    def set_swap(self, swap):
        """
        set_swap(swap self, bool swap)



        Params: (swap)
        """
        return _baz_swig.swap_set_swap(self, swap)


    def get_swap(self):
        """
        get_swap(swap self) -> bool



        Params: (NONE)
        """
        return _baz_swig.swap_get_swap(self)

    __swig_destroy__ = _baz_swig.delete_swap
    __del__ = lambda self: None
swap_swigregister = _baz_swig.swap_swigregister
swap_swigregister(swap)

def swap_make(item_size, vlen, swap=True):
    """
    swap_make(int item_size, int vlen, bool swap=True) -> swap_sptr



    Params: (item_size, vlen, swap)
    """
    return _baz_swig.swap_make(item_size, vlen, swap)

class swap_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::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::baz::swap)> self) -> swap_sptr
        __init__(boost::shared_ptr<(gr::baz::swap)> self, swap p) -> swap_sptr
        """
        this = _baz_swig.new_swap_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(swap_sptr self) -> swap"""
        return _baz_swig.swap_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_swap_sptr
    __del__ = lambda self: None

    def make(self, item_size, vlen, swap=True):
        """
        make(swap_sptr self, int item_size, int vlen, bool swap=True) -> swap_sptr



        Params: (item_size, vlen, swap)
        """
        return _baz_swig.swap_sptr_make(self, item_size, vlen, swap)


    def set_swap(self, swap):
        """
        set_swap(swap_sptr self, bool swap)



        Params: (swap)
        """
        return _baz_swig.swap_sptr_set_swap(self, swap)


    def get_swap(self):
        """
        get_swap(swap_sptr self) -> bool



        Params: (NONE)
        """
        return _baz_swig.swap_sptr_get_swap(self)


    def history(self):
        """history(swap_sptr self) -> unsigned int"""
        return _baz_swig.swap_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(swap_sptr self, int which, int delay)
        declare_sample_delay(swap_sptr self, unsigned int delay)
        """
        return _baz_swig.swap_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(swap_sptr self, int which) -> unsigned int"""
        return _baz_swig.swap_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(swap_sptr self) -> int"""
        return _baz_swig.swap_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(swap_sptr self) -> double"""
        return _baz_swig.swap_sptr_relative_rate(self)


    def start(self):
        """start(swap_sptr self) -> bool"""
        return _baz_swig.swap_sptr_start(self)


    def stop(self):
        """stop(swap_sptr self) -> bool"""
        return _baz_swig.swap_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(swap_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.swap_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(swap_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.swap_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(swap_sptr self) -> int"""
        return _baz_swig.swap_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(swap_sptr self, int m)"""
        return _baz_swig.swap_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(swap_sptr self)"""
        return _baz_swig.swap_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(swap_sptr self) -> bool"""
        return _baz_swig.swap_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(swap_sptr self, int m)"""
        return _baz_swig.swap_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(swap_sptr self) -> int"""
        return _baz_swig.swap_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(swap_sptr self, int i) -> long"""
        return _baz_swig.swap_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(swap_sptr self, long max_output_buffer)
        set_max_output_buffer(swap_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.swap_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(swap_sptr self, int i) -> long"""
        return _baz_swig.swap_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(swap_sptr self, long min_output_buffer)
        set_min_output_buffer(swap_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.swap_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(swap_sptr self, int which) -> float
        pc_input_buffers_full(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(swap_sptr self, int which) -> float
        pc_input_buffers_full_avg(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(swap_sptr self, int which) -> float
        pc_input_buffers_full_var(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(swap_sptr self, int which) -> float
        pc_output_buffers_full(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(swap_sptr self, int which) -> float
        pc_output_buffers_full_avg(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(swap_sptr self, int which) -> float
        pc_output_buffers_full_var(swap_sptr self) -> pmt_vector_float
        """
        return _baz_swig.swap_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(swap_sptr self) -> float"""
        return _baz_swig.swap_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(swap_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.swap_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(swap_sptr self)"""
        return _baz_swig.swap_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(swap_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.swap_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(swap_sptr self) -> int"""
        return _baz_swig.swap_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(swap_sptr self) -> int"""
        return _baz_swig.swap_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(swap_sptr self, int priority) -> int"""
        return _baz_swig.swap_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(swap_sptr self) -> std::string"""
        return _baz_swig.swap_sptr_name(self)


    def symbol_name(self):
        """symbol_name(swap_sptr self) -> std::string"""
        return _baz_swig.swap_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(swap_sptr self) -> io_signature_sptr"""
        return _baz_swig.swap_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(swap_sptr self) -> io_signature_sptr"""
        return _baz_swig.swap_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(swap_sptr self) -> long"""
        return _baz_swig.swap_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(swap_sptr self) -> basic_block_sptr"""
        return _baz_swig.swap_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(swap_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.swap_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(swap_sptr self) -> std::string"""
        return _baz_swig.swap_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(swap_sptr self, std::string name)"""
        return _baz_swig.swap_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(swap_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.swap_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(swap_sptr self) -> swig_int_ptr"""
        return _baz_swig.swap_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(swap_sptr self) -> swig_int_ptr"""
        return _baz_swig.swap_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(swap_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.swap_sptr_message_subscribers(self, which_port)

swap_sptr_swigregister = _baz_swig.swap_sptr_swigregister
swap_sptr_swigregister(swap_sptr)


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

class interleaver(object):
    """
    Detect the peak of a signal.

    If a peak is detected, this block outputs a 1, or it outputs 0's.
    """

    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, vlen_in, vlen_out, out_trigger=0, output_ports=1, top_down_in=False, vector_in=True, vector_out=True, verbose=False):
        """
        make(int item_size, int vlen_in, int vlen_out, int out_trigger=0, int output_ports=1, bool top_down_in=False, bool vector_in=True, bool vector_out=True, bool verbose=False) -> interleaver_sptr



        Params: (item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)
        """
        return _baz_swig.interleaver_make(item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)

    make = staticmethod(make)
    __swig_destroy__ = _baz_swig.delete_interleaver
    __del__ = lambda self: None
interleaver_swigregister = _baz_swig.interleaver_swigregister
interleaver_swigregister(interleaver)

def interleaver_make(item_size, vlen_in, vlen_out, out_trigger=0, output_ports=1, top_down_in=False, vector_in=True, vector_out=True, verbose=False):
    """
    interleaver_make(int item_size, int vlen_in, int vlen_out, int out_trigger=0, int output_ports=1, bool top_down_in=False, bool vector_in=True, bool vector_out=True, bool verbose=False) -> interleaver_sptr



    Params: (item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)
    """
    return _baz_swig.interleaver_make(item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)

class interleaver_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::interleaver)> class."""

    thisown = _swig_property(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::baz::interleaver)> self) -> interleaver_sptr
        __init__(boost::shared_ptr<(gr::baz::interleaver)> self, interleaver p) -> interleaver_sptr
        """
        this = _baz_swig.new_interleaver_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(interleaver_sptr self) -> interleaver"""
        return _baz_swig.interleaver_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_interleaver_sptr
    __del__ = lambda self: None

    def make(self, item_size, vlen_in, vlen_out, out_trigger=0, output_ports=1, top_down_in=False, vector_in=True, vector_out=True, verbose=False):
        """
        make(interleaver_sptr self, int item_size, int vlen_in, int vlen_out, int out_trigger=0, int output_ports=1, bool top_down_in=False, bool vector_in=True, bool vector_out=True, bool verbose=False) -> interleaver_sptr



        Params: (item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)
        """
        return _baz_swig.interleaver_sptr_make(self, item_size, vlen_in, vlen_out, out_trigger, output_ports, top_down_in, vector_in, vector_out, verbose)


    def history(self):
        """history(interleaver_sptr self) -> unsigned int"""
        return _baz_swig.interleaver_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(interleaver_sptr self, int which, int delay)
        declare_sample_delay(interleaver_sptr self, unsigned int delay)
        """
        return _baz_swig.interleaver_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(interleaver_sptr self, int which) -> unsigned int"""
        return _baz_swig.interleaver_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(interleaver_sptr self) -> int"""
        return _baz_swig.interleaver_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(interleaver_sptr self) -> double"""
        return _baz_swig.interleaver_sptr_relative_rate(self)


    def start(self):
        """start(interleaver_sptr self) -> bool"""
        return _baz_swig.interleaver_sptr_start(self)


    def stop(self):
        """stop(interleaver_sptr self) -> bool"""
        return _baz_swig.interleaver_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(interleaver_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.interleaver_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(interleaver_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.interleaver_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(interleaver_sptr self) -> int"""
        return _baz_swig.interleaver_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(interleaver_sptr self, int m)"""
        return _baz_swig.interleaver_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(interleaver_sptr self)"""
        return _baz_swig.interleaver_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(interleaver_sptr self) -> bool"""
        return _baz_swig.interleaver_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(interleaver_sptr self, int m)"""
        return _baz_swig.interleaver_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(interleaver_sptr self) -> int"""
        return _baz_swig.interleaver_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(interleaver_sptr self, int i) -> long"""
        return _baz_swig.interleaver_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(interleaver_sptr self, long max_output_buffer)
        set_max_output_buffer(interleaver_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.interleaver_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(interleaver_sptr self, int i) -> long"""
        return _baz_swig.interleaver_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(interleaver_sptr self, long min_output_buffer)
        set_min_output_buffer(interleaver_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.interleaver_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(interleaver_sptr self, int which) -> float
        pc_input_buffers_full(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(interleaver_sptr self, int which) -> float
        pc_input_buffers_full_avg(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(interleaver_sptr self, int which) -> float
        pc_input_buffers_full_var(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(interleaver_sptr self, int which) -> float
        pc_output_buffers_full(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(interleaver_sptr self, int which) -> float
        pc_output_buffers_full_avg(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(interleaver_sptr self, int which) -> float
        pc_output_buffers_full_var(interleaver_sptr self) -> pmt_vector_float
        """
        return _baz_swig.interleaver_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(interleaver_sptr self) -> float"""
        return _baz_swig.interleaver_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(interleaver_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.interleaver_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(interleaver_sptr self)"""
        return _baz_swig.interleaver_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(interleaver_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.interleaver_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(interleaver_sptr self) -> int"""
        return _baz_swig.interleaver_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(interleaver_sptr self) -> int"""
        return _baz_swig.interleaver_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(interleaver_sptr self, int priority) -> int"""
        return _baz_swig.interleaver_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(interleaver_sptr self) -> std::string"""
        return _baz_swig.interleaver_sptr_name(self)


    def symbol_name(self):
        """symbol_name(interleaver_sptr self) -> std::string"""
        return _baz_swig.interleaver_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(interleaver_sptr self) -> io_signature_sptr"""
        return _baz_swig.interleaver_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(interleaver_sptr self) -> io_signature_sptr"""
        return _baz_swig.interleaver_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(interleaver_sptr self) -> long"""
        return _baz_swig.interleaver_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(interleaver_sptr self) -> basic_block_sptr"""
        return _baz_swig.interleaver_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(interleaver_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.interleaver_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(interleaver_sptr self) -> std::string"""
        return _baz_swig.interleaver_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(interleaver_sptr self, std::string name)"""
        return _baz_swig.interleaver_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(interleaver_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.interleaver_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(interleaver_sptr self) -> swig_int_ptr"""
        return _baz_swig.interleaver_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(interleaver_sptr self) -> swig_int_ptr"""
        return _baz_swig.interleaver_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(interleaver_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.interleaver_sptr_message_subscribers(self, which_port)

interleaver_sptr_swigregister = _baz_swig.interleaver_sptr_swigregister
interleaver_sptr_swigregister(interleaver_sptr)


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

class field_tracker(object):
    """
    Detect the peak of a signal.

    If a peak is detected, this block outputs a 1, or it outputs 0's.
    """

    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, input_length, output_length):
        """
        make(int item_size, int input_length, int output_length) -> field_tracker_sptr



        Params: (item_size, input_length, output_length)
        """
        return _baz_swig.field_tracker_make(item_size, input_length, output_length)

    make = staticmethod(make)
    __swig_destroy__ = _baz_swig.delete_field_tracker
    __del__ = lambda self: None
field_tracker_swigregister = _baz_swig.field_tracker_swigregister
field_tracker_swigregister(field_tracker)

def field_tracker_make(item_size, input_length, output_length):
    """
    field_tracker_make(int item_size, int input_length, int output_length) -> field_tracker_sptr



    Params: (item_size, input_length, output_length)
    """
    return _baz_swig.field_tracker_make(item_size, input_length, output_length)

class field_tracker_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::field_tracker)> class."""

    thisown = _swig_property(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::baz::field_tracker)> self) -> field_tracker_sptr
        __init__(boost::shared_ptr<(gr::baz::field_tracker)> self, field_tracker p) -> field_tracker_sptr
        """
        this = _baz_swig.new_field_tracker_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(field_tracker_sptr self) -> field_tracker"""
        return _baz_swig.field_tracker_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_field_tracker_sptr
    __del__ = lambda self: None

    def make(self, item_size, input_length, output_length):
        """
        make(field_tracker_sptr self, int item_size, int input_length, int output_length) -> field_tracker_sptr



        Params: (item_size, input_length, output_length)
        """
        return _baz_swig.field_tracker_sptr_make(self, item_size, input_length, output_length)


    def history(self):
        """history(field_tracker_sptr self) -> unsigned int"""
        return _baz_swig.field_tracker_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(field_tracker_sptr self, int which, int delay)
        declare_sample_delay(field_tracker_sptr self, unsigned int delay)
        """
        return _baz_swig.field_tracker_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(field_tracker_sptr self, int which) -> unsigned int"""
        return _baz_swig.field_tracker_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(field_tracker_sptr self) -> int"""
        return _baz_swig.field_tracker_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(field_tracker_sptr self) -> double"""
        return _baz_swig.field_tracker_sptr_relative_rate(self)


    def start(self):
        """start(field_tracker_sptr self) -> bool"""
        return _baz_swig.field_tracker_sptr_start(self)


    def stop(self):
        """stop(field_tracker_sptr self) -> bool"""
        return _baz_swig.field_tracker_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(field_tracker_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.field_tracker_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(field_tracker_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.field_tracker_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(field_tracker_sptr self) -> int"""
        return _baz_swig.field_tracker_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(field_tracker_sptr self, int m)"""
        return _baz_swig.field_tracker_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(field_tracker_sptr self)"""
        return _baz_swig.field_tracker_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(field_tracker_sptr self) -> bool"""
        return _baz_swig.field_tracker_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(field_tracker_sptr self, int m)"""
        return _baz_swig.field_tracker_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(field_tracker_sptr self) -> int"""
        return _baz_swig.field_tracker_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(field_tracker_sptr self, int i) -> long"""
        return _baz_swig.field_tracker_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(field_tracker_sptr self, long max_output_buffer)
        set_max_output_buffer(field_tracker_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.field_tracker_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(field_tracker_sptr self, int i) -> long"""
        return _baz_swig.field_tracker_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(field_tracker_sptr self, long min_output_buffer)
        set_min_output_buffer(field_tracker_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.field_tracker_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(field_tracker_sptr self, int which) -> float
        pc_input_buffers_full(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(field_tracker_sptr self, int which) -> float
        pc_input_buffers_full_avg(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(field_tracker_sptr self, int which) -> float
        pc_input_buffers_full_var(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(field_tracker_sptr self, int which) -> float
        pc_output_buffers_full(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(field_tracker_sptr self, int which) -> float
        pc_output_buffers_full_avg(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(field_tracker_sptr self, int which) -> float
        pc_output_buffers_full_var(field_tracker_sptr self) -> pmt_vector_float
        """
        return _baz_swig.field_tracker_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(field_tracker_sptr self) -> float"""
        return _baz_swig.field_tracker_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(field_tracker_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.field_tracker_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(field_tracker_sptr self)"""
        return _baz_swig.field_tracker_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(field_tracker_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.field_tracker_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(field_tracker_sptr self) -> int"""
        return _baz_swig.field_tracker_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(field_tracker_sptr self) -> int"""
        return _baz_swig.field_tracker_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(field_tracker_sptr self, int priority) -> int"""
        return _baz_swig.field_tracker_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(field_tracker_sptr self) -> std::string"""
        return _baz_swig.field_tracker_sptr_name(self)


    def symbol_name(self):
        """symbol_name(field_tracker_sptr self) -> std::string"""
        return _baz_swig.field_tracker_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(field_tracker_sptr self) -> io_signature_sptr"""
        return _baz_swig.field_tracker_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(field_tracker_sptr self) -> io_signature_sptr"""
        return _baz_swig.field_tracker_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(field_tracker_sptr self) -> long"""
        return _baz_swig.field_tracker_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(field_tracker_sptr self) -> basic_block_sptr"""
        return _baz_swig.field_tracker_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(field_tracker_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.field_tracker_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(field_tracker_sptr self) -> std::string"""
        return _baz_swig.field_tracker_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(field_tracker_sptr self, std::string name)"""
        return _baz_swig.field_tracker_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(field_tracker_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.field_tracker_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(field_tracker_sptr self) -> swig_int_ptr"""
        return _baz_swig.field_tracker_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(field_tracker_sptr self) -> swig_int_ptr"""
        return _baz_swig.field_tracker_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(field_tracker_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.field_tracker_sptr_message_subscribers(self, which_port)

field_tracker_sptr_swigregister = _baz_swig.field_tracker_sptr_swigregister
field_tracker_sptr_swigregister(field_tracker_sptr)


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

class keep_one_in_n(object):
    """decimate a stream, keeping one item out of every ."""

    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(itemsize, n, verbose=False):
        """
        make(size_t itemsize, int n, bool verbose=False) -> keep_one_in_n_sptr

        Make a keep one in n block.

        Params: (itemsize, n, verbose)
        """
        return _baz_swig.keep_one_in_n_make(itemsize, n, verbose)

    make = staticmethod(make)

    def set_n(self, n):
        """
        set_n(keep_one_in_n self, int n)



        Params: (n)
        """
        return _baz_swig.keep_one_in_n_set_n(self, n)

    __swig_destroy__ = _baz_swig.delete_keep_one_in_n
    __del__ = lambda self: None
keep_one_in_n_swigregister = _baz_swig.keep_one_in_n_swigregister
keep_one_in_n_swigregister(keep_one_in_n)

def keep_one_in_n_make(itemsize, n, verbose=False):
    """
    keep_one_in_n_make(size_t itemsize, int n, bool verbose=False) -> keep_one_in_n_sptr

    Make a keep one in n block.

    Params: (itemsize, n, verbose)
    """
    return _baz_swig.keep_one_in_n_make(itemsize, n, verbose)

class keep_one_in_n_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::keep_one_in_n)> class."""

    thisown = _swig_property(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::baz::keep_one_in_n)> self) -> keep_one_in_n_sptr
        __init__(boost::shared_ptr<(gr::baz::keep_one_in_n)> self, keep_one_in_n p) -> keep_one_in_n_sptr
        """
        this = _baz_swig.new_keep_one_in_n_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(keep_one_in_n_sptr self) -> keep_one_in_n"""
        return _baz_swig.keep_one_in_n_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_keep_one_in_n_sptr
    __del__ = lambda self: None

    def make(self, itemsize, n, verbose=False):
        """
        make(keep_one_in_n_sptr self, size_t itemsize, int n, bool verbose=False) -> keep_one_in_n_sptr

        Make a keep one in n block.

        Params: (itemsize, n, verbose)
        """
        return _baz_swig.keep_one_in_n_sptr_make(self, itemsize, n, verbose)


    def set_n(self, n):
        """
        set_n(keep_one_in_n_sptr self, int n)



        Params: (n)
        """
        return _baz_swig.keep_one_in_n_sptr_set_n(self, n)


    def history(self):
        """history(keep_one_in_n_sptr self) -> unsigned int"""
        return _baz_swig.keep_one_in_n_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(keep_one_in_n_sptr self, int which, int delay)
        declare_sample_delay(keep_one_in_n_sptr self, unsigned int delay)
        """
        return _baz_swig.keep_one_in_n_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(keep_one_in_n_sptr self, int which) -> unsigned int"""
        return _baz_swig.keep_one_in_n_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(keep_one_in_n_sptr self) -> int"""
        return _baz_swig.keep_one_in_n_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(keep_one_in_n_sptr self) -> double"""
        return _baz_swig.keep_one_in_n_sptr_relative_rate(self)


    def start(self):
        """start(keep_one_in_n_sptr self) -> bool"""
        return _baz_swig.keep_one_in_n_sptr_start(self)


    def stop(self):
        """stop(keep_one_in_n_sptr self) -> bool"""
        return _baz_swig.keep_one_in_n_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(keep_one_in_n_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.keep_one_in_n_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(keep_one_in_n_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.keep_one_in_n_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(keep_one_in_n_sptr self) -> int"""
        return _baz_swig.keep_one_in_n_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(keep_one_in_n_sptr self, int m)"""
        return _baz_swig.keep_one_in_n_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(keep_one_in_n_sptr self)"""
        return _baz_swig.keep_one_in_n_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(keep_one_in_n_sptr self) -> bool"""
        return _baz_swig.keep_one_in_n_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(keep_one_in_n_sptr self, int m)"""
        return _baz_swig.keep_one_in_n_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(keep_one_in_n_sptr self) -> int"""
        return _baz_swig.keep_one_in_n_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(keep_one_in_n_sptr self, int i) -> long"""
        return _baz_swig.keep_one_in_n_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(keep_one_in_n_sptr self, long max_output_buffer)
        set_max_output_buffer(keep_one_in_n_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.keep_one_in_n_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(keep_one_in_n_sptr self, int i) -> long"""
        return _baz_swig.keep_one_in_n_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(keep_one_in_n_sptr self, long min_output_buffer)
        set_min_output_buffer(keep_one_in_n_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.keep_one_in_n_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(keep_one_in_n_sptr self, int which) -> float
        pc_input_buffers_full(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(keep_one_in_n_sptr self, int which) -> float
        pc_input_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(keep_one_in_n_sptr self, int which) -> float
        pc_input_buffers_full_var(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(keep_one_in_n_sptr self, int which) -> float
        pc_output_buffers_full(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(keep_one_in_n_sptr self, int which) -> float
        pc_output_buffers_full_avg(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(keep_one_in_n_sptr self, int which) -> float
        pc_output_buffers_full_var(keep_one_in_n_sptr self) -> pmt_vector_float
        """
        return _baz_swig.keep_one_in_n_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(keep_one_in_n_sptr self) -> float"""
        return _baz_swig.keep_one_in_n_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(keep_one_in_n_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.keep_one_in_n_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(keep_one_in_n_sptr self)"""
        return _baz_swig.keep_one_in_n_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(keep_one_in_n_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.keep_one_in_n_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(keep_one_in_n_sptr self) -> int"""
        return _baz_swig.keep_one_in_n_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(keep_one_in_n_sptr self) -> int"""
        return _baz_swig.keep_one_in_n_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(keep_one_in_n_sptr self, int priority) -> int"""
        return _baz_swig.keep_one_in_n_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(keep_one_in_n_sptr self) -> std::string"""
        return _baz_swig.keep_one_in_n_sptr_name(self)


    def symbol_name(self):
        """symbol_name(keep_one_in_n_sptr self) -> std::string"""
        return _baz_swig.keep_one_in_n_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(keep_one_in_n_sptr self) -> io_signature_sptr"""
        return _baz_swig.keep_one_in_n_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(keep_one_in_n_sptr self) -> io_signature_sptr"""
        return _baz_swig.keep_one_in_n_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(keep_one_in_n_sptr self) -> long"""
        return _baz_swig.keep_one_in_n_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(keep_one_in_n_sptr self) -> basic_block_sptr"""
        return _baz_swig.keep_one_in_n_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(keep_one_in_n_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.keep_one_in_n_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(keep_one_in_n_sptr self) -> std::string"""
        return _baz_swig.keep_one_in_n_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(keep_one_in_n_sptr self, std::string name)"""
        return _baz_swig.keep_one_in_n_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(keep_one_in_n_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.keep_one_in_n_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(keep_one_in_n_sptr self) -> swig_int_ptr"""
        return _baz_swig.keep_one_in_n_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(keep_one_in_n_sptr self) -> swig_int_ptr"""
        return _baz_swig.keep_one_in_n_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(keep_one_in_n_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.keep_one_in_n_sptr_message_subscribers(self, which_port)

keep_one_in_n_sptr_swigregister = _baz_swig.keep_one_in_n_sptr_swigregister
keep_one_in_n_sptr_swigregister(keep_one_in_n_sptr)


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

class file_source(object):
    """Read stream from file."""

    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, long offset=0, char const * timing_filename=None, bool pad=False, double rate=0.0, bool auto_load=True, std::vector< std::string,std::allocator< std::string > > const & files) -> file_source_sptr

        Create a file source.

        Opens  as a source of items into a flowgraph. The data is expected to be in binary format, item after item. The  of the block determines the conversion from bits to items.


        If  is turned on, the file will repeat the file after it's reached the end.

        Params: (itemsize, filename, repeat, offset, timing_filename, pad, rate, auto_load, files)
        """
        return _baz_swig.file_source_make(*args, **kwargs)

    make = staticmethod(make)

    def seek(self, *args):
        """
        seek(file_source self, long seek_point) -> bool
        seek(file_source self, long seek_point, int whence) -> bool

        seek file to  relative to

        Params: (seek_point)
        """
        return _baz_swig.file_source_seek(self, *args)


    def open(self, *args, **kwargs):
        """
        open(file_source self, char const * filename, bool repeat=False, long offset=0, char const * timing_filename=None, bool pad=False, double rate=0.0, bool auto_load=True, std::vector< std::string,std::allocator< std::string > > const & files)

        Opens a new file.

        Params: (filename, repeat, offset, timing_filename, pad, rate, auto_load, files)
        """
        return _baz_swig.file_source_open(self, *args, **kwargs)


    def close(self):
        """
        close(file_source self)

        Close the file handle.

        Params: (NONE)
        """
        return _baz_swig.file_source_close(self)


    def offset(self):
        """
        offset(file_source self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_offset(self)


    def file_offset(self):
        """
        file_offset(file_source self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_file_offset(self)


    def time(self, relative=False, raw=False):
        """
        time(file_source self, bool relative=False, bool raw=False) -> double



        Params: (relative, raw)
        """
        return _baz_swig.file_source_time(self, relative, raw)


    def sample_rate(self):
        """
        sample_rate(file_source self) -> double



        Params: (NONE)
        """
        return _baz_swig.file_source_sample_rate(self)


    def sample_count(self, raw=False):
        """
        sample_count(file_source self, bool raw=False) -> double



        Params: (raw)
        """
        return _baz_swig.file_source_sample_count(self, raw)


    def duration(self):
        """
        duration(file_source self) -> double



        Params: (NONE)
        """
        return _baz_swig.file_source_duration(self)


    def file_index(self):
        """
        file_index(file_source self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_file_index(self)


    def file_path(self):
        """
        file_path(file_source self) -> std::string



        Params: (NONE)
        """
        return _baz_swig.file_source_file_path(self)


    def files(self):
        """
        files(file_source self) -> std::vector< std::string,std::allocator< std::string > >



        Params: (NONE)
        """
        return _baz_swig.file_source_files(self)

    __swig_destroy__ = _baz_swig.delete_file_source
    __del__ = lambda self: None
file_source_swigregister = _baz_swig.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, long offset=0, char const * timing_filename=None, bool pad=False, double rate=0.0, bool auto_load=True, std::vector< std::string,std::allocator< std::string > > const & files) -> file_source_sptr

    Create a file source.

    Opens  as a source of items into a flowgraph. The data is expected to be in binary format, item after item. The  of the block determines the conversion from bits to items.


    If  is turned on, the file will repeat the file after it's reached the end.

    Params: (itemsize, filename, repeat, offset, timing_filename, pad, rate, auto_load, files)
    """
    return _baz_swig.file_source_make(*args, **kwargs)

class file_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::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::baz::file_source)> self) -> file_source_sptr
        __init__(boost::shared_ptr<(gr::baz::file_source)> self, file_source p) -> file_source_sptr
        """
        this = _baz_swig.new_file_source_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(file_source_sptr self) -> file_source"""
        return _baz_swig.file_source_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.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, long offset=0, char const * timing_filename=None, bool pad=False, double rate=0.0, bool auto_load=True, std::vector< std::string,std::allocator< std::string > > const & files) -> file_source_sptr

        Create a file source.

        Opens  as a source of items into a flowgraph. The data is expected to be in binary format, item after item. The  of the block determines the conversion from bits to items.


        If  is turned on, the file will repeat the file after it's reached the end.

        Params: (itemsize, filename, repeat, offset, timing_filename, pad, rate, auto_load, files)
        """
        return _baz_swig.file_source_sptr_make(self, *args, **kwargs)


    def seek(self, *args):
        """
        seek(file_source_sptr self, long seek_point) -> bool
        seek(file_source_sptr self, long seek_point, int whence) -> bool

        seek file to  relative to

        Params: (seek_point)
        """
        return _baz_swig.file_source_sptr_seek(self, *args)


    def open(self, *args, **kwargs):
        """
        open(file_source_sptr self, char const * filename, bool repeat=False, long offset=0, char const * timing_filename=None, bool pad=False, double rate=0.0, bool auto_load=True, std::vector< std::string,std::allocator< std::string > > const & files)

        Opens a new file.

        Params: (filename, repeat, offset, timing_filename, pad, rate, auto_load, files)
        """
        return _baz_swig.file_source_sptr_open(self, *args, **kwargs)


    def close(self):
        """
        close(file_source_sptr self)

        Close the file handle.

        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_close(self)


    def offset(self):
        """
        offset(file_source_sptr self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_offset(self)


    def file_offset(self):
        """
        file_offset(file_source_sptr self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_file_offset(self)


    def time(self, relative=False, raw=False):
        """
        time(file_source_sptr self, bool relative=False, bool raw=False) -> double



        Params: (relative, raw)
        """
        return _baz_swig.file_source_sptr_time(self, relative, raw)


    def sample_rate(self):
        """
        sample_rate(file_source_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_sample_rate(self)


    def sample_count(self, raw=False):
        """
        sample_count(file_source_sptr self, bool raw=False) -> double



        Params: (raw)
        """
        return _baz_swig.file_source_sptr_sample_count(self, raw)


    def duration(self):
        """
        duration(file_source_sptr self) -> double



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_duration(self)


    def file_index(self):
        """
        file_index(file_source_sptr self) -> size_t



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_file_index(self)


    def file_path(self):
        """
        file_path(file_source_sptr self) -> std::string



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_file_path(self)


    def files(self):
        """
        files(file_source_sptr self) -> std::vector< std::string,std::allocator< std::string > >



        Params: (NONE)
        """
        return _baz_swig.file_source_sptr_files(self)


    def history(self):
        """history(file_source_sptr self) -> unsigned int"""
        return _baz_swig.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 _baz_swig.file_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_source_sptr self, int which) -> unsigned int"""
        return _baz_swig.file_source_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """nitems_read(file_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.file_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.file_source_sptr_nitems_written(self, which_output)


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


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_source_sptr self, int m)"""
        return _baz_swig.file_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_source_sptr self)"""
        return _baz_swig.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 _baz_swig.file_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_source_sptr self, int m)"""
        return _baz_swig.file_source_sptr_set_min_noutput_items(self, m)


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


    def max_output_buffer(self, i):
        """max_output_buffer(file_source_sptr self, int i) -> long"""
        return _baz_swig.file_source_sptr_max_output_buffer(self, i)


    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 _baz_swig.file_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_source_sptr self, int i) -> long"""
        return _baz_swig.file_source_sptr_min_output_buffer(self, i)


    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 _baz_swig.file_source_sptr_set_min_output_buffer(self, *args)


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


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


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


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


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


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_source_sptr self) -> float"""
        return _baz_swig.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 _baz_swig.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 _baz_swig.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 _baz_swig.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 _baz_swig.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 _baz_swig.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 _baz_swig.file_source_sptr_pc_output_buffers_full_var(self, *args)


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


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


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


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


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


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


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


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


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


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


    def set_thread_priority(self, priority):
        """set_thread_priority(file_source_sptr self, int priority) -> int"""
        return _baz_swig.file_source_sptr_set_thread_priority(self, priority)


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


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


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


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


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


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


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.file_source_sptr_check_topology(self, ninputs, noutputs)


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


    def set_block_alias(self, name):
        """set_block_alias(file_source_sptr self, std::string name)"""
        return _baz_swig.file_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.file_source_sptr__post(self, which_port, msg)


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


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


    def message_subscribers(self, which_port):
        """message_subscribers(file_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.file_source_sptr_message_subscribers(self, which_port)

file_source_sptr_swigregister = _baz_swig.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 sdl_sink_uc(object):
    """
    video sink using SDL

    input signature is one, two or three streams of uchar. One stream: stream is grey (Y) two streems: first is grey (Y), second is alternating U and V Three streams: first is grey (Y), second is U, third is V Input samples must be in the range [0,255].
    """

    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(double framerate, int width, int height, unsigned int format, int dst_width, int dst_height, std::string const filename, bool manual_flip=False, std::string const font_path) -> sdl_sink_uc_sptr



        Params: (framerate, width, height, format, dst_width, dst_height, filename, manual_flip, font_path)
        """
        return _baz_swig.sdl_sink_uc_make(*args, **kwargs)

    make = staticmethod(make)

    def flip(self):
        """
        flip(sdl_sink_uc self)



        Params: ()
        """
        return _baz_swig.sdl_sink_uc_flip(self)

    __swig_destroy__ = _baz_swig.delete_sdl_sink_uc
    __del__ = lambda self: None
sdl_sink_uc_swigregister = _baz_swig.sdl_sink_uc_swigregister
sdl_sink_uc_swigregister(sdl_sink_uc)

def sdl_sink_uc_make(*args, **kwargs):
    """
    sdl_sink_uc_make(double framerate, int width, int height, unsigned int format, int dst_width, int dst_height, std::string const filename, bool manual_flip=False, std::string const font_path) -> sdl_sink_uc_sptr



    Params: (framerate, width, height, format, dst_width, dst_height, filename, manual_flip, font_path)
    """
    return _baz_swig.sdl_sink_uc_make(*args, **kwargs)

class sdl_sink_uc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::baz::sdl_sink_uc)> class."""

    thisown = _swig_property(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::baz::sdl_sink_uc)> self) -> sdl_sink_uc_sptr
        __init__(boost::shared_ptr<(gr::baz::sdl_sink_uc)> self, sdl_sink_uc p) -> sdl_sink_uc_sptr
        """
        this = _baz_swig.new_sdl_sink_uc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(sdl_sink_uc_sptr self) -> sdl_sink_uc"""
        return _baz_swig.sdl_sink_uc_sptr___deref__(self)

    __swig_destroy__ = _baz_swig.delete_sdl_sink_uc_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(sdl_sink_uc_sptr self, double framerate, int width, int height, unsigned int format, int dst_width, int dst_height, std::string const filename, bool manual_flip=False, std::string const font_path) -> sdl_sink_uc_sptr



        Params: (framerate, width, height, format, dst_width, dst_height, filename, manual_flip, font_path)
        """
        return _baz_swig.sdl_sink_uc_sptr_make(self, *args, **kwargs)


    def flip(self):
        """
        flip(sdl_sink_uc_sptr self)



        Params: ()
        """
        return _baz_swig.sdl_sink_uc_sptr_flip(self)


    def history(self):
        """history(sdl_sink_uc_sptr self) -> unsigned int"""
        return _baz_swig.sdl_sink_uc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sdl_sink_uc_sptr self, int which, int delay)
        declare_sample_delay(sdl_sink_uc_sptr self, unsigned int delay)
        """
        return _baz_swig.sdl_sink_uc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sdl_sink_uc_sptr self, int which) -> unsigned int"""
        return _baz_swig.sdl_sink_uc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sdl_sink_uc_sptr self) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sdl_sink_uc_sptr self) -> double"""
        return _baz_swig.sdl_sink_uc_sptr_relative_rate(self)


    def start(self):
        """start(sdl_sink_uc_sptr self) -> bool"""
        return _baz_swig.sdl_sink_uc_sptr_start(self)


    def stop(self):
        """stop(sdl_sink_uc_sptr self) -> bool"""
        return _baz_swig.sdl_sink_uc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sdl_sink_uc_sptr self, unsigned int which_input) -> uint64_t"""
        return _baz_swig.sdl_sink_uc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sdl_sink_uc_sptr self, unsigned int which_output) -> uint64_t"""
        return _baz_swig.sdl_sink_uc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sdl_sink_uc_sptr self) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sdl_sink_uc_sptr self, int m)"""
        return _baz_swig.sdl_sink_uc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sdl_sink_uc_sptr self)"""
        return _baz_swig.sdl_sink_uc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sdl_sink_uc_sptr self) -> bool"""
        return _baz_swig.sdl_sink_uc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sdl_sink_uc_sptr self, int m)"""
        return _baz_swig.sdl_sink_uc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sdl_sink_uc_sptr self) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sdl_sink_uc_sptr self, int i) -> long"""
        return _baz_swig.sdl_sink_uc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sdl_sink_uc_sptr self, long max_output_buffer)
        set_max_output_buffer(sdl_sink_uc_sptr self, int port, long max_output_buffer)
        """
        return _baz_swig.sdl_sink_uc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sdl_sink_uc_sptr self, int i) -> long"""
        return _baz_swig.sdl_sink_uc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sdl_sink_uc_sptr self, long min_output_buffer)
        set_min_output_buffer(sdl_sink_uc_sptr self, int port, long min_output_buffer)
        """
        return _baz_swig.sdl_sink_uc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sdl_sink_uc_sptr self, int which) -> float
        pc_input_buffers_full(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sdl_sink_uc_sptr self, int which) -> float
        pc_input_buffers_full_avg(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sdl_sink_uc_sptr self, int which) -> float
        pc_input_buffers_full_var(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sdl_sink_uc_sptr self, int which) -> float
        pc_output_buffers_full(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sdl_sink_uc_sptr self, int which) -> float
        pc_output_buffers_full_avg(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sdl_sink_uc_sptr self, int which) -> float
        pc_output_buffers_full_var(sdl_sink_uc_sptr self) -> pmt_vector_float
        """
        return _baz_swig.sdl_sink_uc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sdl_sink_uc_sptr self) -> float"""
        return _baz_swig.sdl_sink_uc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sdl_sink_uc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _baz_swig.sdl_sink_uc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sdl_sink_uc_sptr self)"""
        return _baz_swig.sdl_sink_uc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sdl_sink_uc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _baz_swig.sdl_sink_uc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sdl_sink_uc_sptr self) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sdl_sink_uc_sptr self) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sdl_sink_uc_sptr self, int priority) -> int"""
        return _baz_swig.sdl_sink_uc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sdl_sink_uc_sptr self) -> std::string"""
        return _baz_swig.sdl_sink_uc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sdl_sink_uc_sptr self) -> std::string"""
        return _baz_swig.sdl_sink_uc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sdl_sink_uc_sptr self) -> io_signature_sptr"""
        return _baz_swig.sdl_sink_uc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sdl_sink_uc_sptr self) -> io_signature_sptr"""
        return _baz_swig.sdl_sink_uc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sdl_sink_uc_sptr self) -> long"""
        return _baz_swig.sdl_sink_uc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sdl_sink_uc_sptr self) -> basic_block_sptr"""
        return _baz_swig.sdl_sink_uc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sdl_sink_uc_sptr self, int ninputs, int noutputs) -> bool"""
        return _baz_swig.sdl_sink_uc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sdl_sink_uc_sptr self) -> std::string"""
        return _baz_swig.sdl_sink_uc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sdl_sink_uc_sptr self, std::string name)"""
        return _baz_swig.sdl_sink_uc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sdl_sink_uc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _baz_swig.sdl_sink_uc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sdl_sink_uc_sptr self) -> swig_int_ptr"""
        return _baz_swig.sdl_sink_uc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sdl_sink_uc_sptr self) -> swig_int_ptr"""
        return _baz_swig.sdl_sink_uc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sdl_sink_uc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _baz_swig.sdl_sink_uc_sptr_message_subscribers(self, which_port)

sdl_sink_uc_sptr_swigregister = _baz_swig.sdl_sink_uc_sptr_swigregister
sdl_sink_uc_sptr_swigregister(sdl_sink_uc_sptr)


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



