# 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, '_csnd6')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_csnd6')
    _csnd6 = 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('_csnd6', [dirname(__file__)])
        except ImportError:
            import _csnd6
            return _csnd6
        try:
            _mod = imp.load_module('_csnd6', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _csnd6 = swig_import_helper()
    del swig_import_helper
else:
    import _csnd6
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _csnd6.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _csnd6.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _csnd6.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _csnd6.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _csnd6.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _csnd6.SwigPyIterator_equal(self, x)

    def copy(self):
        return _csnd6.SwigPyIterator_copy(self)

    def next(self):
        return _csnd6.SwigPyIterator_next(self)

    def __next__(self):
        return _csnd6.SwigPyIterator___next__(self)

    def previous(self):
        return _csnd6.SwigPyIterator_previous(self)

    def advance(self, n):
        return _csnd6.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _csnd6.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _csnd6.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _csnd6.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _csnd6.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _csnd6.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _csnd6.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _csnd6.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def new_intp(nelements):
    return _csnd6.new_intp(nelements)
new_intp = _csnd6.new_intp

def delete_intp(ary):
    return _csnd6.delete_intp(ary)
delete_intp = _csnd6.delete_intp

def intp_getitem(ary, index):
    return _csnd6.intp_getitem(ary, index)
intp_getitem = _csnd6.intp_getitem

def intp_setitem(ary, index, value):
    return _csnd6.intp_setitem(ary, index, value)
intp_setitem = _csnd6.intp_setitem

def new_floatp(nelements):
    return _csnd6.new_floatp(nelements)
new_floatp = _csnd6.new_floatp

def delete_floatp(ary):
    return _csnd6.delete_floatp(ary)
delete_floatp = _csnd6.delete_floatp

def floatp_getitem(ary, index):
    return _csnd6.floatp_getitem(ary, index)
floatp_getitem = _csnd6.floatp_getitem

def floatp_setitem(ary, index, value):
    return _csnd6.floatp_setitem(ary, index, value)
floatp_setitem = _csnd6.floatp_setitem

def new_doublep(nelements):
    return _csnd6.new_doublep(nelements)
new_doublep = _csnd6.new_doublep

def delete_doublep(ary):
    return _csnd6.delete_doublep(ary)
delete_doublep = _csnd6.delete_doublep

def doublep_getitem(ary, index):
    return _csnd6.doublep_getitem(ary, index)
doublep_getitem = _csnd6.doublep_getitem

def doublep_setitem(ary, index, value):
    return _csnd6.doublep_setitem(ary, index, value)
doublep_setitem = _csnd6.doublep_setitem
class intArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _csnd6.new_intArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_intArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _csnd6.intArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _csnd6.intArray___setitem__(self, index, value)

    def cast(self):
        return _csnd6.intArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_csnd6.intArray_frompointer)
    else:
        frompointer = _csnd6.intArray_frompointer
intArray_swigregister = _csnd6.intArray_swigregister
intArray_swigregister(intArray)

def intArray_frompointer(t):
    return _csnd6.intArray_frompointer(t)
intArray_frompointer = _csnd6.intArray_frompointer

class floatArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floatArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floatArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _csnd6.new_floatArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_floatArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _csnd6.floatArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _csnd6.floatArray___setitem__(self, index, value)

    def cast(self):
        return _csnd6.floatArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_csnd6.floatArray_frompointer)
    else:
        frompointer = _csnd6.floatArray_frompointer
floatArray_swigregister = _csnd6.floatArray_swigregister
floatArray_swigregister(floatArray)

def floatArray_frompointer(t):
    return _csnd6.floatArray_frompointer(t)
floatArray_frompointer = _csnd6.floatArray_frompointer

class doubleArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doubleArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doubleArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _csnd6.new_doubleArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_doubleArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _csnd6.doubleArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _csnd6.doubleArray___setitem__(self, index, value)

    def cast(self):
        return _csnd6.doubleArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_csnd6.doubleArray_frompointer)
    else:
        frompointer = _csnd6.doubleArray_frompointer
doubleArray_swigregister = _csnd6.doubleArray_swigregister
doubleArray_swigregister(doubleArray)

def doubleArray_frompointer(t):
    return _csnd6.doubleArray_frompointer(t)
doubleArray_frompointer = _csnd6.doubleArray_frompointer

CSOUND_SUCCESS = _csnd6.CSOUND_SUCCESS
CSOUND_ERROR = _csnd6.CSOUND_ERROR
CSOUND_INITIALIZATION = _csnd6.CSOUND_INITIALIZATION
CSOUND_PERFORMANCE = _csnd6.CSOUND_PERFORMANCE
CSOUND_MEMORY = _csnd6.CSOUND_MEMORY
CSOUND_SIGNAL = _csnd6.CSOUND_SIGNAL
CSOUND_EXITJMP_SUCCESS = _csnd6.CSOUND_EXITJMP_SUCCESS
CSOUNDINIT_NO_SIGNAL_HANDLER = _csnd6.CSOUNDINIT_NO_SIGNAL_HANDLER
CSOUNDINIT_NO_ATEXIT = _csnd6.CSOUNDINIT_NO_ATEXIT
CSOUND_CALLBACK_KBD_EVENT = _csnd6.CSOUND_CALLBACK_KBD_EVENT
CSOUND_CALLBACK_KBD_TEXT = _csnd6.CSOUND_CALLBACK_KBD_TEXT
CSFTYPE_UNIFIED_CSD = _csnd6.CSFTYPE_UNIFIED_CSD
CSFTYPE_ORCHESTRA = _csnd6.CSFTYPE_ORCHESTRA
CSFTYPE_SCORE = _csnd6.CSFTYPE_SCORE
CSFTYPE_ORC_INCLUDE = _csnd6.CSFTYPE_ORC_INCLUDE
CSFTYPE_SCO_INCLUDE = _csnd6.CSFTYPE_SCO_INCLUDE
CSFTYPE_SCORE_OUT = _csnd6.CSFTYPE_SCORE_OUT
CSFTYPE_SCOT = _csnd6.CSFTYPE_SCOT
CSFTYPE_OPTIONS = _csnd6.CSFTYPE_OPTIONS
CSFTYPE_EXTRACT_PARMS = _csnd6.CSFTYPE_EXTRACT_PARMS
CSFTYPE_RAW_AUDIO = _csnd6.CSFTYPE_RAW_AUDIO
CSFTYPE_IRCAM = _csnd6.CSFTYPE_IRCAM
CSFTYPE_AIFF = _csnd6.CSFTYPE_AIFF
CSFTYPE_AIFC = _csnd6.CSFTYPE_AIFC
CSFTYPE_WAVE = _csnd6.CSFTYPE_WAVE
CSFTYPE_AU = _csnd6.CSFTYPE_AU
CSFTYPE_SD2 = _csnd6.CSFTYPE_SD2
CSFTYPE_W64 = _csnd6.CSFTYPE_W64
CSFTYPE_WAVEX = _csnd6.CSFTYPE_WAVEX
CSFTYPE_FLAC = _csnd6.CSFTYPE_FLAC
CSFTYPE_CAF = _csnd6.CSFTYPE_CAF
CSFTYPE_WVE = _csnd6.CSFTYPE_WVE
CSFTYPE_OGG = _csnd6.CSFTYPE_OGG
CSFTYPE_MPC2K = _csnd6.CSFTYPE_MPC2K
CSFTYPE_RF64 = _csnd6.CSFTYPE_RF64
CSFTYPE_AVR = _csnd6.CSFTYPE_AVR
CSFTYPE_HTK = _csnd6.CSFTYPE_HTK
CSFTYPE_MAT4 = _csnd6.CSFTYPE_MAT4
CSFTYPE_MAT5 = _csnd6.CSFTYPE_MAT5
CSFTYPE_NIST = _csnd6.CSFTYPE_NIST
CSFTYPE_PAF = _csnd6.CSFTYPE_PAF
CSFTYPE_PVF = _csnd6.CSFTYPE_PVF
CSFTYPE_SDS = _csnd6.CSFTYPE_SDS
CSFTYPE_SVX = _csnd6.CSFTYPE_SVX
CSFTYPE_VOC = _csnd6.CSFTYPE_VOC
CSFTYPE_XI = _csnd6.CSFTYPE_XI
CSFTYPE_UNKNOWN_AUDIO = _csnd6.CSFTYPE_UNKNOWN_AUDIO
CSFTYPE_SOUNDFONT = _csnd6.CSFTYPE_SOUNDFONT
CSFTYPE_STD_MIDI = _csnd6.CSFTYPE_STD_MIDI
CSFTYPE_MIDI_SYSEX = _csnd6.CSFTYPE_MIDI_SYSEX
CSFTYPE_HETRO = _csnd6.CSFTYPE_HETRO
CSFTYPE_HETROT = _csnd6.CSFTYPE_HETROT
CSFTYPE_PVC = _csnd6.CSFTYPE_PVC
CSFTYPE_PVCEX = _csnd6.CSFTYPE_PVCEX
CSFTYPE_CVANAL = _csnd6.CSFTYPE_CVANAL
CSFTYPE_LPC = _csnd6.CSFTYPE_LPC
CSFTYPE_ATS = _csnd6.CSFTYPE_ATS
CSFTYPE_LORIS = _csnd6.CSFTYPE_LORIS
CSFTYPE_SDIF = _csnd6.CSFTYPE_SDIF
CSFTYPE_HRTF = _csnd6.CSFTYPE_HRTF
CSFTYPE_UNUSED = _csnd6.CSFTYPE_UNUSED
CSFTYPE_LADSPA_PLUGIN = _csnd6.CSFTYPE_LADSPA_PLUGIN
CSFTYPE_SNAPSHOT = _csnd6.CSFTYPE_SNAPSHOT
CSFTYPE_FTABLES_TEXT = _csnd6.CSFTYPE_FTABLES_TEXT
CSFTYPE_FTABLES_BINARY = _csnd6.CSFTYPE_FTABLES_BINARY
CSFTYPE_XSCANU_MATRIX = _csnd6.CSFTYPE_XSCANU_MATRIX
CSFTYPE_FLOATS_TEXT = _csnd6.CSFTYPE_FLOATS_TEXT
CSFTYPE_FLOATS_BINARY = _csnd6.CSFTYPE_FLOATS_BINARY
CSFTYPE_INTEGER_TEXT = _csnd6.CSFTYPE_INTEGER_TEXT
CSFTYPE_INTEGER_BINARY = _csnd6.CSFTYPE_INTEGER_BINARY
CSFTYPE_IMAGE_PNG = _csnd6.CSFTYPE_IMAGE_PNG
CSFTYPE_POSTSCRIPT = _csnd6.CSFTYPE_POSTSCRIPT
CSFTYPE_SCRIPT_TEXT = _csnd6.CSFTYPE_SCRIPT_TEXT
CSFTYPE_OTHER_TEXT = _csnd6.CSFTYPE_OTHER_TEXT
CSFTYPE_OTHER_BINARY = _csnd6.CSFTYPE_OTHER_BINARY
CSFTYPE_UNKNOWN = _csnd6.CSFTYPE_UNKNOWN
class CSOUND_PARAMS(_object):
    """Proxy of C++ CSOUND_PARAMS class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSOUND_PARAMS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CSOUND_PARAMS, name)
    __repr__ = _swig_repr
    __swig_setmethods__["debug_mode"] = _csnd6.CSOUND_PARAMS_debug_mode_set
    __swig_getmethods__["debug_mode"] = _csnd6.CSOUND_PARAMS_debug_mode_get
    if _newclass:
        debug_mode = _swig_property(_csnd6.CSOUND_PARAMS_debug_mode_get, _csnd6.CSOUND_PARAMS_debug_mode_set)
    __swig_setmethods__["buffer_frames"] = _csnd6.CSOUND_PARAMS_buffer_frames_set
    __swig_getmethods__["buffer_frames"] = _csnd6.CSOUND_PARAMS_buffer_frames_get
    if _newclass:
        buffer_frames = _swig_property(_csnd6.CSOUND_PARAMS_buffer_frames_get, _csnd6.CSOUND_PARAMS_buffer_frames_set)
    __swig_setmethods__["hardware_buffer_frames"] = _csnd6.CSOUND_PARAMS_hardware_buffer_frames_set
    __swig_getmethods__["hardware_buffer_frames"] = _csnd6.CSOUND_PARAMS_hardware_buffer_frames_get
    if _newclass:
        hardware_buffer_frames = _swig_property(_csnd6.CSOUND_PARAMS_hardware_buffer_frames_get, _csnd6.CSOUND_PARAMS_hardware_buffer_frames_set)
    __swig_setmethods__["displays"] = _csnd6.CSOUND_PARAMS_displays_set
    __swig_getmethods__["displays"] = _csnd6.CSOUND_PARAMS_displays_get
    if _newclass:
        displays = _swig_property(_csnd6.CSOUND_PARAMS_displays_get, _csnd6.CSOUND_PARAMS_displays_set)
    __swig_setmethods__["ascii_graphs"] = _csnd6.CSOUND_PARAMS_ascii_graphs_set
    __swig_getmethods__["ascii_graphs"] = _csnd6.CSOUND_PARAMS_ascii_graphs_get
    if _newclass:
        ascii_graphs = _swig_property(_csnd6.CSOUND_PARAMS_ascii_graphs_get, _csnd6.CSOUND_PARAMS_ascii_graphs_set)
    __swig_setmethods__["postscript_graphs"] = _csnd6.CSOUND_PARAMS_postscript_graphs_set
    __swig_getmethods__["postscript_graphs"] = _csnd6.CSOUND_PARAMS_postscript_graphs_get
    if _newclass:
        postscript_graphs = _swig_property(_csnd6.CSOUND_PARAMS_postscript_graphs_get, _csnd6.CSOUND_PARAMS_postscript_graphs_set)
    __swig_setmethods__["message_level"] = _csnd6.CSOUND_PARAMS_message_level_set
    __swig_getmethods__["message_level"] = _csnd6.CSOUND_PARAMS_message_level_get
    if _newclass:
        message_level = _swig_property(_csnd6.CSOUND_PARAMS_message_level_get, _csnd6.CSOUND_PARAMS_message_level_set)
    __swig_setmethods__["tempo"] = _csnd6.CSOUND_PARAMS_tempo_set
    __swig_getmethods__["tempo"] = _csnd6.CSOUND_PARAMS_tempo_get
    if _newclass:
        tempo = _swig_property(_csnd6.CSOUND_PARAMS_tempo_get, _csnd6.CSOUND_PARAMS_tempo_set)
    __swig_setmethods__["ring_bell"] = _csnd6.CSOUND_PARAMS_ring_bell_set
    __swig_getmethods__["ring_bell"] = _csnd6.CSOUND_PARAMS_ring_bell_get
    if _newclass:
        ring_bell = _swig_property(_csnd6.CSOUND_PARAMS_ring_bell_get, _csnd6.CSOUND_PARAMS_ring_bell_set)
    __swig_setmethods__["use_cscore"] = _csnd6.CSOUND_PARAMS_use_cscore_set
    __swig_getmethods__["use_cscore"] = _csnd6.CSOUND_PARAMS_use_cscore_get
    if _newclass:
        use_cscore = _swig_property(_csnd6.CSOUND_PARAMS_use_cscore_get, _csnd6.CSOUND_PARAMS_use_cscore_set)
    __swig_setmethods__["terminate_on_midi"] = _csnd6.CSOUND_PARAMS_terminate_on_midi_set
    __swig_getmethods__["terminate_on_midi"] = _csnd6.CSOUND_PARAMS_terminate_on_midi_get
    if _newclass:
        terminate_on_midi = _swig_property(_csnd6.CSOUND_PARAMS_terminate_on_midi_get, _csnd6.CSOUND_PARAMS_terminate_on_midi_set)
    __swig_setmethods__["heartbeat"] = _csnd6.CSOUND_PARAMS_heartbeat_set
    __swig_getmethods__["heartbeat"] = _csnd6.CSOUND_PARAMS_heartbeat_get
    if _newclass:
        heartbeat = _swig_property(_csnd6.CSOUND_PARAMS_heartbeat_get, _csnd6.CSOUND_PARAMS_heartbeat_set)
    __swig_setmethods__["defer_gen01_load"] = _csnd6.CSOUND_PARAMS_defer_gen01_load_set
    __swig_getmethods__["defer_gen01_load"] = _csnd6.CSOUND_PARAMS_defer_gen01_load_get
    if _newclass:
        defer_gen01_load = _swig_property(_csnd6.CSOUND_PARAMS_defer_gen01_load_get, _csnd6.CSOUND_PARAMS_defer_gen01_load_set)
    __swig_setmethods__["midi_key"] = _csnd6.CSOUND_PARAMS_midi_key_set
    __swig_getmethods__["midi_key"] = _csnd6.CSOUND_PARAMS_midi_key_get
    if _newclass:
        midi_key = _swig_property(_csnd6.CSOUND_PARAMS_midi_key_get, _csnd6.CSOUND_PARAMS_midi_key_set)
    __swig_setmethods__["midi_key_cps"] = _csnd6.CSOUND_PARAMS_midi_key_cps_set
    __swig_getmethods__["midi_key_cps"] = _csnd6.CSOUND_PARAMS_midi_key_cps_get
    if _newclass:
        midi_key_cps = _swig_property(_csnd6.CSOUND_PARAMS_midi_key_cps_get, _csnd6.CSOUND_PARAMS_midi_key_cps_set)
    __swig_setmethods__["midi_key_oct"] = _csnd6.CSOUND_PARAMS_midi_key_oct_set
    __swig_getmethods__["midi_key_oct"] = _csnd6.CSOUND_PARAMS_midi_key_oct_get
    if _newclass:
        midi_key_oct = _swig_property(_csnd6.CSOUND_PARAMS_midi_key_oct_get, _csnd6.CSOUND_PARAMS_midi_key_oct_set)
    __swig_setmethods__["midi_key_pch"] = _csnd6.CSOUND_PARAMS_midi_key_pch_set
    __swig_getmethods__["midi_key_pch"] = _csnd6.CSOUND_PARAMS_midi_key_pch_get
    if _newclass:
        midi_key_pch = _swig_property(_csnd6.CSOUND_PARAMS_midi_key_pch_get, _csnd6.CSOUND_PARAMS_midi_key_pch_set)
    __swig_setmethods__["midi_velocity"] = _csnd6.CSOUND_PARAMS_midi_velocity_set
    __swig_getmethods__["midi_velocity"] = _csnd6.CSOUND_PARAMS_midi_velocity_get
    if _newclass:
        midi_velocity = _swig_property(_csnd6.CSOUND_PARAMS_midi_velocity_get, _csnd6.CSOUND_PARAMS_midi_velocity_set)
    __swig_setmethods__["midi_velocity_amp"] = _csnd6.CSOUND_PARAMS_midi_velocity_amp_set
    __swig_getmethods__["midi_velocity_amp"] = _csnd6.CSOUND_PARAMS_midi_velocity_amp_get
    if _newclass:
        midi_velocity_amp = _swig_property(_csnd6.CSOUND_PARAMS_midi_velocity_amp_get, _csnd6.CSOUND_PARAMS_midi_velocity_amp_set)
    __swig_setmethods__["no_default_paths"] = _csnd6.CSOUND_PARAMS_no_default_paths_set
    __swig_getmethods__["no_default_paths"] = _csnd6.CSOUND_PARAMS_no_default_paths_get
    if _newclass:
        no_default_paths = _swig_property(_csnd6.CSOUND_PARAMS_no_default_paths_get, _csnd6.CSOUND_PARAMS_no_default_paths_set)
    __swig_setmethods__["number_of_threads"] = _csnd6.CSOUND_PARAMS_number_of_threads_set
    __swig_getmethods__["number_of_threads"] = _csnd6.CSOUND_PARAMS_number_of_threads_get
    if _newclass:
        number_of_threads = _swig_property(_csnd6.CSOUND_PARAMS_number_of_threads_get, _csnd6.CSOUND_PARAMS_number_of_threads_set)
    __swig_setmethods__["syntax_check_only"] = _csnd6.CSOUND_PARAMS_syntax_check_only_set
    __swig_getmethods__["syntax_check_only"] = _csnd6.CSOUND_PARAMS_syntax_check_only_get
    if _newclass:
        syntax_check_only = _swig_property(_csnd6.CSOUND_PARAMS_syntax_check_only_get, _csnd6.CSOUND_PARAMS_syntax_check_only_set)
    __swig_setmethods__["csd_line_counts"] = _csnd6.CSOUND_PARAMS_csd_line_counts_set
    __swig_getmethods__["csd_line_counts"] = _csnd6.CSOUND_PARAMS_csd_line_counts_get
    if _newclass:
        csd_line_counts = _swig_property(_csnd6.CSOUND_PARAMS_csd_line_counts_get, _csnd6.CSOUND_PARAMS_csd_line_counts_set)
    __swig_setmethods__["compute_weights"] = _csnd6.CSOUND_PARAMS_compute_weights_set
    __swig_getmethods__["compute_weights"] = _csnd6.CSOUND_PARAMS_compute_weights_get
    if _newclass:
        compute_weights = _swig_property(_csnd6.CSOUND_PARAMS_compute_weights_get, _csnd6.CSOUND_PARAMS_compute_weights_set)
    __swig_setmethods__["realtime_mode"] = _csnd6.CSOUND_PARAMS_realtime_mode_set
    __swig_getmethods__["realtime_mode"] = _csnd6.CSOUND_PARAMS_realtime_mode_get
    if _newclass:
        realtime_mode = _swig_property(_csnd6.CSOUND_PARAMS_realtime_mode_get, _csnd6.CSOUND_PARAMS_realtime_mode_set)
    __swig_setmethods__["sample_accurate"] = _csnd6.CSOUND_PARAMS_sample_accurate_set
    __swig_getmethods__["sample_accurate"] = _csnd6.CSOUND_PARAMS_sample_accurate_get
    if _newclass:
        sample_accurate = _swig_property(_csnd6.CSOUND_PARAMS_sample_accurate_get, _csnd6.CSOUND_PARAMS_sample_accurate_set)
    __swig_setmethods__["sample_rate_override"] = _csnd6.CSOUND_PARAMS_sample_rate_override_set
    __swig_getmethods__["sample_rate_override"] = _csnd6.CSOUND_PARAMS_sample_rate_override_get
    if _newclass:
        sample_rate_override = _swig_property(_csnd6.CSOUND_PARAMS_sample_rate_override_get, _csnd6.CSOUND_PARAMS_sample_rate_override_set)
    __swig_setmethods__["control_rate_override"] = _csnd6.CSOUND_PARAMS_control_rate_override_set
    __swig_getmethods__["control_rate_override"] = _csnd6.CSOUND_PARAMS_control_rate_override_get
    if _newclass:
        control_rate_override = _swig_property(_csnd6.CSOUND_PARAMS_control_rate_override_get, _csnd6.CSOUND_PARAMS_control_rate_override_set)
    __swig_setmethods__["nchnls_override"] = _csnd6.CSOUND_PARAMS_nchnls_override_set
    __swig_getmethods__["nchnls_override"] = _csnd6.CSOUND_PARAMS_nchnls_override_get
    if _newclass:
        nchnls_override = _swig_property(_csnd6.CSOUND_PARAMS_nchnls_override_get, _csnd6.CSOUND_PARAMS_nchnls_override_set)
    __swig_setmethods__["nchnls_i_override"] = _csnd6.CSOUND_PARAMS_nchnls_i_override_set
    __swig_getmethods__["nchnls_i_override"] = _csnd6.CSOUND_PARAMS_nchnls_i_override_get
    if _newclass:
        nchnls_i_override = _swig_property(_csnd6.CSOUND_PARAMS_nchnls_i_override_get, _csnd6.CSOUND_PARAMS_nchnls_i_override_set)
    __swig_setmethods__["e0dbfs_override"] = _csnd6.CSOUND_PARAMS_e0dbfs_override_set
    __swig_getmethods__["e0dbfs_override"] = _csnd6.CSOUND_PARAMS_e0dbfs_override_get
    if _newclass:
        e0dbfs_override = _swig_property(_csnd6.CSOUND_PARAMS_e0dbfs_override_get, _csnd6.CSOUND_PARAMS_e0dbfs_override_set)
    __swig_setmethods__["daemon"] = _csnd6.CSOUND_PARAMS_daemon_set
    __swig_getmethods__["daemon"] = _csnd6.CSOUND_PARAMS_daemon_get
    if _newclass:
        daemon = _swig_property(_csnd6.CSOUND_PARAMS_daemon_get, _csnd6.CSOUND_PARAMS_daemon_set)
    __swig_setmethods__["ksmps_override"] = _csnd6.CSOUND_PARAMS_ksmps_override_set
    __swig_getmethods__["ksmps_override"] = _csnd6.CSOUND_PARAMS_ksmps_override_get
    if _newclass:
        ksmps_override = _swig_property(_csnd6.CSOUND_PARAMS_ksmps_override_get, _csnd6.CSOUND_PARAMS_ksmps_override_set)
    __swig_setmethods__["FFT_library"] = _csnd6.CSOUND_PARAMS_FFT_library_set
    __swig_getmethods__["FFT_library"] = _csnd6.CSOUND_PARAMS_FFT_library_get
    if _newclass:
        FFT_library = _swig_property(_csnd6.CSOUND_PARAMS_FFT_library_get, _csnd6.CSOUND_PARAMS_FFT_library_set)

    def __init__(self):
        """__init__(CSOUND_PARAMS self) -> CSOUND_PARAMS"""
        this = _csnd6.new_CSOUND_PARAMS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CSOUND_PARAMS
    __del__ = lambda self: None
CSOUND_PARAMS_swigregister = _csnd6.CSOUND_PARAMS_swigregister
CSOUND_PARAMS_swigregister(CSOUND_PARAMS)

class CS_AUDIODEVICE(_object):
    """Proxy of C++ CS_AUDIODEVICE class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CS_AUDIODEVICE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CS_AUDIODEVICE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["device_name"] = _csnd6.CS_AUDIODEVICE_device_name_set
    __swig_getmethods__["device_name"] = _csnd6.CS_AUDIODEVICE_device_name_get
    if _newclass:
        device_name = _swig_property(_csnd6.CS_AUDIODEVICE_device_name_get, _csnd6.CS_AUDIODEVICE_device_name_set)
    __swig_setmethods__["device_id"] = _csnd6.CS_AUDIODEVICE_device_id_set
    __swig_getmethods__["device_id"] = _csnd6.CS_AUDIODEVICE_device_id_get
    if _newclass:
        device_id = _swig_property(_csnd6.CS_AUDIODEVICE_device_id_get, _csnd6.CS_AUDIODEVICE_device_id_set)
    __swig_setmethods__["rt_module"] = _csnd6.CS_AUDIODEVICE_rt_module_set
    __swig_getmethods__["rt_module"] = _csnd6.CS_AUDIODEVICE_rt_module_get
    if _newclass:
        rt_module = _swig_property(_csnd6.CS_AUDIODEVICE_rt_module_get, _csnd6.CS_AUDIODEVICE_rt_module_set)
    __swig_setmethods__["max_nchnls"] = _csnd6.CS_AUDIODEVICE_max_nchnls_set
    __swig_getmethods__["max_nchnls"] = _csnd6.CS_AUDIODEVICE_max_nchnls_get
    if _newclass:
        max_nchnls = _swig_property(_csnd6.CS_AUDIODEVICE_max_nchnls_get, _csnd6.CS_AUDIODEVICE_max_nchnls_set)
    __swig_setmethods__["isOutput"] = _csnd6.CS_AUDIODEVICE_isOutput_set
    __swig_getmethods__["isOutput"] = _csnd6.CS_AUDIODEVICE_isOutput_get
    if _newclass:
        isOutput = _swig_property(_csnd6.CS_AUDIODEVICE_isOutput_get, _csnd6.CS_AUDIODEVICE_isOutput_set)

    def __init__(self):
        """__init__(CS_AUDIODEVICE self) -> CS_AUDIODEVICE"""
        this = _csnd6.new_CS_AUDIODEVICE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CS_AUDIODEVICE
    __del__ = lambda self: None
CS_AUDIODEVICE_swigregister = _csnd6.CS_AUDIODEVICE_swigregister
CS_AUDIODEVICE_swigregister(CS_AUDIODEVICE)

class CS_MIDIDEVICE(_object):
    """Proxy of C++ CS_MIDIDEVICE class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CS_MIDIDEVICE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CS_MIDIDEVICE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["device_name"] = _csnd6.CS_MIDIDEVICE_device_name_set
    __swig_getmethods__["device_name"] = _csnd6.CS_MIDIDEVICE_device_name_get
    if _newclass:
        device_name = _swig_property(_csnd6.CS_MIDIDEVICE_device_name_get, _csnd6.CS_MIDIDEVICE_device_name_set)
    __swig_setmethods__["interface_name"] = _csnd6.CS_MIDIDEVICE_interface_name_set
    __swig_getmethods__["interface_name"] = _csnd6.CS_MIDIDEVICE_interface_name_get
    if _newclass:
        interface_name = _swig_property(_csnd6.CS_MIDIDEVICE_interface_name_get, _csnd6.CS_MIDIDEVICE_interface_name_set)
    __swig_setmethods__["device_id"] = _csnd6.CS_MIDIDEVICE_device_id_set
    __swig_getmethods__["device_id"] = _csnd6.CS_MIDIDEVICE_device_id_get
    if _newclass:
        device_id = _swig_property(_csnd6.CS_MIDIDEVICE_device_id_get, _csnd6.CS_MIDIDEVICE_device_id_set)
    __swig_setmethods__["midi_module"] = _csnd6.CS_MIDIDEVICE_midi_module_set
    __swig_getmethods__["midi_module"] = _csnd6.CS_MIDIDEVICE_midi_module_get
    if _newclass:
        midi_module = _swig_property(_csnd6.CS_MIDIDEVICE_midi_module_get, _csnd6.CS_MIDIDEVICE_midi_module_set)
    __swig_setmethods__["isOutput"] = _csnd6.CS_MIDIDEVICE_isOutput_set
    __swig_getmethods__["isOutput"] = _csnd6.CS_MIDIDEVICE_isOutput_get
    if _newclass:
        isOutput = _swig_property(_csnd6.CS_MIDIDEVICE_isOutput_get, _csnd6.CS_MIDIDEVICE_isOutput_set)

    def __init__(self):
        """__init__(CS_MIDIDEVICE self) -> CS_MIDIDEVICE"""
        this = _csnd6.new_CS_MIDIDEVICE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CS_MIDIDEVICE
    __del__ = lambda self: None
CS_MIDIDEVICE_swigregister = _csnd6.CS_MIDIDEVICE_swigregister
CS_MIDIDEVICE_swigregister(CS_MIDIDEVICE)

class csRtAudioParams(_object):
    """Proxy of C++ csRtAudioParams class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csRtAudioParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csRtAudioParams, name)
    __repr__ = _swig_repr
    __swig_setmethods__["devName"] = _csnd6.csRtAudioParams_devName_set
    __swig_getmethods__["devName"] = _csnd6.csRtAudioParams_devName_get
    if _newclass:
        devName = _swig_property(_csnd6.csRtAudioParams_devName_get, _csnd6.csRtAudioParams_devName_set)
    __swig_setmethods__["devNum"] = _csnd6.csRtAudioParams_devNum_set
    __swig_getmethods__["devNum"] = _csnd6.csRtAudioParams_devNum_get
    if _newclass:
        devNum = _swig_property(_csnd6.csRtAudioParams_devNum_get, _csnd6.csRtAudioParams_devNum_set)
    __swig_setmethods__["bufSamp_SW"] = _csnd6.csRtAudioParams_bufSamp_SW_set
    __swig_getmethods__["bufSamp_SW"] = _csnd6.csRtAudioParams_bufSamp_SW_get
    if _newclass:
        bufSamp_SW = _swig_property(_csnd6.csRtAudioParams_bufSamp_SW_get, _csnd6.csRtAudioParams_bufSamp_SW_set)
    __swig_setmethods__["bufSamp_HW"] = _csnd6.csRtAudioParams_bufSamp_HW_set
    __swig_getmethods__["bufSamp_HW"] = _csnd6.csRtAudioParams_bufSamp_HW_get
    if _newclass:
        bufSamp_HW = _swig_property(_csnd6.csRtAudioParams_bufSamp_HW_get, _csnd6.csRtAudioParams_bufSamp_HW_set)
    __swig_setmethods__["nChannels"] = _csnd6.csRtAudioParams_nChannels_set
    __swig_getmethods__["nChannels"] = _csnd6.csRtAudioParams_nChannels_get
    if _newclass:
        nChannels = _swig_property(_csnd6.csRtAudioParams_nChannels_get, _csnd6.csRtAudioParams_nChannels_set)
    __swig_setmethods__["sampleFormat"] = _csnd6.csRtAudioParams_sampleFormat_set
    __swig_getmethods__["sampleFormat"] = _csnd6.csRtAudioParams_sampleFormat_get
    if _newclass:
        sampleFormat = _swig_property(_csnd6.csRtAudioParams_sampleFormat_get, _csnd6.csRtAudioParams_sampleFormat_set)
    __swig_setmethods__["sampleRate"] = _csnd6.csRtAudioParams_sampleRate_set
    __swig_getmethods__["sampleRate"] = _csnd6.csRtAudioParams_sampleRate_get
    if _newclass:
        sampleRate = _swig_property(_csnd6.csRtAudioParams_sampleRate_get, _csnd6.csRtAudioParams_sampleRate_set)

    def __init__(self):
        """__init__(csRtAudioParams self) -> csRtAudioParams"""
        this = _csnd6.new_csRtAudioParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csRtAudioParams
    __del__ = lambda self: None
csRtAudioParams_swigregister = _csnd6.csRtAudioParams_swigregister
csRtAudioParams_swigregister(csRtAudioParams)

class RTCLOCK(_object):
    """Proxy of C++ RTCLOCK_S class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RTCLOCK, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RTCLOCK, name)
    __repr__ = _swig_repr
    __swig_setmethods__["starttime_real"] = _csnd6.RTCLOCK_starttime_real_set
    __swig_getmethods__["starttime_real"] = _csnd6.RTCLOCK_starttime_real_get
    if _newclass:
        starttime_real = _swig_property(_csnd6.RTCLOCK_starttime_real_get, _csnd6.RTCLOCK_starttime_real_set)
    __swig_setmethods__["starttime_CPU"] = _csnd6.RTCLOCK_starttime_CPU_set
    __swig_getmethods__["starttime_CPU"] = _csnd6.RTCLOCK_starttime_CPU_get
    if _newclass:
        starttime_CPU = _swig_property(_csnd6.RTCLOCK_starttime_CPU_get, _csnd6.RTCLOCK_starttime_CPU_set)

    def __init__(self):
        """__init__(RTCLOCK_S self) -> RTCLOCK"""
        this = _csnd6.new_RTCLOCK()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_RTCLOCK
    __del__ = lambda self: None
RTCLOCK_swigregister = _csnd6.RTCLOCK_swigregister
RTCLOCK_swigregister(RTCLOCK)

class opcodeListEntry(_object):
    """Proxy of C++ opcodeListEntry class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, opcodeListEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, opcodeListEntry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["opname"] = _csnd6.opcodeListEntry_opname_set
    __swig_getmethods__["opname"] = _csnd6.opcodeListEntry_opname_get
    if _newclass:
        opname = _swig_property(_csnd6.opcodeListEntry_opname_get, _csnd6.opcodeListEntry_opname_set)
    __swig_setmethods__["outypes"] = _csnd6.opcodeListEntry_outypes_set
    __swig_getmethods__["outypes"] = _csnd6.opcodeListEntry_outypes_get
    if _newclass:
        outypes = _swig_property(_csnd6.opcodeListEntry_outypes_get, _csnd6.opcodeListEntry_outypes_set)
    __swig_setmethods__["intypes"] = _csnd6.opcodeListEntry_intypes_set
    __swig_getmethods__["intypes"] = _csnd6.opcodeListEntry_intypes_get
    if _newclass:
        intypes = _swig_property(_csnd6.opcodeListEntry_intypes_get, _csnd6.opcodeListEntry_intypes_set)
    __swig_setmethods__["flags"] = _csnd6.opcodeListEntry_flags_set
    __swig_getmethods__["flags"] = _csnd6.opcodeListEntry_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.opcodeListEntry_flags_get, _csnd6.opcodeListEntry_flags_set)

    def __init__(self):
        """__init__(opcodeListEntry self) -> opcodeListEntry"""
        this = _csnd6.new_opcodeListEntry()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_opcodeListEntry
    __del__ = lambda self: None
opcodeListEntry_swigregister = _csnd6.opcodeListEntry_swigregister
opcodeListEntry_swigregister(opcodeListEntry)

class CsoundRandMTState(_object):
    """Proxy of C++ CsoundRandMTState_ class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundRandMTState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundRandMTState, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mti"] = _csnd6.CsoundRandMTState_mti_set
    __swig_getmethods__["mti"] = _csnd6.CsoundRandMTState_mti_get
    if _newclass:
        mti = _swig_property(_csnd6.CsoundRandMTState_mti_get, _csnd6.CsoundRandMTState_mti_set)
    __swig_setmethods__["mt"] = _csnd6.CsoundRandMTState_mt_set
    __swig_getmethods__["mt"] = _csnd6.CsoundRandMTState_mt_get
    if _newclass:
        mt = _swig_property(_csnd6.CsoundRandMTState_mt_get, _csnd6.CsoundRandMTState_mt_set)

    def __init__(self):
        """__init__(CsoundRandMTState_ self) -> CsoundRandMTState"""
        this = _csnd6.new_CsoundRandMTState()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundRandMTState
    __del__ = lambda self: None
CsoundRandMTState_swigregister = _csnd6.CsoundRandMTState_swigregister
CsoundRandMTState_swigregister(CsoundRandMTState)

class PVSDATEXT(_object):
    """Proxy of C++ pvsdat_ext class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PVSDATEXT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PVSDATEXT, name)
    __repr__ = _swig_repr
    __swig_setmethods__["N"] = _csnd6.PVSDATEXT_N_set
    __swig_getmethods__["N"] = _csnd6.PVSDATEXT_N_get
    if _newclass:
        N = _swig_property(_csnd6.PVSDATEXT_N_get, _csnd6.PVSDATEXT_N_set)
    __swig_setmethods__["sliding"] = _csnd6.PVSDATEXT_sliding_set
    __swig_getmethods__["sliding"] = _csnd6.PVSDATEXT_sliding_get
    if _newclass:
        sliding = _swig_property(_csnd6.PVSDATEXT_sliding_get, _csnd6.PVSDATEXT_sliding_set)
    __swig_setmethods__["NB"] = _csnd6.PVSDATEXT_NB_set
    __swig_getmethods__["NB"] = _csnd6.PVSDATEXT_NB_get
    if _newclass:
        NB = _swig_property(_csnd6.PVSDATEXT_NB_get, _csnd6.PVSDATEXT_NB_set)
    __swig_setmethods__["overlap"] = _csnd6.PVSDATEXT_overlap_set
    __swig_getmethods__["overlap"] = _csnd6.PVSDATEXT_overlap_get
    if _newclass:
        overlap = _swig_property(_csnd6.PVSDATEXT_overlap_get, _csnd6.PVSDATEXT_overlap_set)
    __swig_setmethods__["winsize"] = _csnd6.PVSDATEXT_winsize_set
    __swig_getmethods__["winsize"] = _csnd6.PVSDATEXT_winsize_get
    if _newclass:
        winsize = _swig_property(_csnd6.PVSDATEXT_winsize_get, _csnd6.PVSDATEXT_winsize_set)
    __swig_setmethods__["wintype"] = _csnd6.PVSDATEXT_wintype_set
    __swig_getmethods__["wintype"] = _csnd6.PVSDATEXT_wintype_get
    if _newclass:
        wintype = _swig_property(_csnd6.PVSDATEXT_wintype_get, _csnd6.PVSDATEXT_wintype_set)
    __swig_setmethods__["format"] = _csnd6.PVSDATEXT_format_set
    __swig_getmethods__["format"] = _csnd6.PVSDATEXT_format_get
    if _newclass:
        format = _swig_property(_csnd6.PVSDATEXT_format_get, _csnd6.PVSDATEXT_format_set)
    __swig_setmethods__["framecount"] = _csnd6.PVSDATEXT_framecount_set
    __swig_getmethods__["framecount"] = _csnd6.PVSDATEXT_framecount_get
    if _newclass:
        framecount = _swig_property(_csnd6.PVSDATEXT_framecount_get, _csnd6.PVSDATEXT_framecount_set)
    __swig_setmethods__["frame"] = _csnd6.PVSDATEXT_frame_set
    __swig_getmethods__["frame"] = _csnd6.PVSDATEXT_frame_get
    if _newclass:
        frame = _swig_property(_csnd6.PVSDATEXT_frame_get, _csnd6.PVSDATEXT_frame_set)

    def __init__(self):
        """__init__(pvsdat_ext self) -> PVSDATEXT"""
        this = _csnd6.new_PVSDATEXT()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_PVSDATEXT
    __del__ = lambda self: None
PVSDATEXT_swigregister = _csnd6.PVSDATEXT_swigregister
PVSDATEXT_swigregister(PVSDATEXT)

class ORCTOKEN(_object):
    """Proxy of C++ ORCTOKEN class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ORCTOKEN, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ORCTOKEN, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _csnd6.ORCTOKEN_type_set
    __swig_getmethods__["type"] = _csnd6.ORCTOKEN_type_get
    if _newclass:
        type = _swig_property(_csnd6.ORCTOKEN_type_get, _csnd6.ORCTOKEN_type_set)
    __swig_setmethods__["lexeme"] = _csnd6.ORCTOKEN_lexeme_set
    __swig_getmethods__["lexeme"] = _csnd6.ORCTOKEN_lexeme_get
    if _newclass:
        lexeme = _swig_property(_csnd6.ORCTOKEN_lexeme_get, _csnd6.ORCTOKEN_lexeme_set)
    __swig_setmethods__["value"] = _csnd6.ORCTOKEN_value_set
    __swig_getmethods__["value"] = _csnd6.ORCTOKEN_value_get
    if _newclass:
        value = _swig_property(_csnd6.ORCTOKEN_value_get, _csnd6.ORCTOKEN_value_set)
    __swig_setmethods__["fvalue"] = _csnd6.ORCTOKEN_fvalue_set
    __swig_getmethods__["fvalue"] = _csnd6.ORCTOKEN_fvalue_get
    if _newclass:
        fvalue = _swig_property(_csnd6.ORCTOKEN_fvalue_get, _csnd6.ORCTOKEN_fvalue_set)
    __swig_setmethods__["optype"] = _csnd6.ORCTOKEN_optype_set
    __swig_getmethods__["optype"] = _csnd6.ORCTOKEN_optype_get
    if _newclass:
        optype = _swig_property(_csnd6.ORCTOKEN_optype_get, _csnd6.ORCTOKEN_optype_set)
    __swig_setmethods__["next"] = _csnd6.ORCTOKEN_next_set
    __swig_getmethods__["next"] = _csnd6.ORCTOKEN_next_get
    if _newclass:
        next = _swig_property(_csnd6.ORCTOKEN_next_get, _csnd6.ORCTOKEN_next_set)

    def __init__(self):
        """__init__(ORCTOKEN self) -> ORCTOKEN"""
        this = _csnd6.new_ORCTOKEN()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_ORCTOKEN
    __del__ = lambda self: None
ORCTOKEN_swigregister = _csnd6.ORCTOKEN_swigregister
ORCTOKEN_swigregister(ORCTOKEN)

class TREE(_object):
    """Proxy of C++ TREE class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TREE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TREE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _csnd6.TREE_type_set
    __swig_getmethods__["type"] = _csnd6.TREE_type_get
    if _newclass:
        type = _swig_property(_csnd6.TREE_type_get, _csnd6.TREE_type_set)
    __swig_setmethods__["value"] = _csnd6.TREE_value_set
    __swig_getmethods__["value"] = _csnd6.TREE_value_get
    if _newclass:
        value = _swig_property(_csnd6.TREE_value_get, _csnd6.TREE_value_set)
    __swig_setmethods__["rate"] = _csnd6.TREE_rate_set
    __swig_getmethods__["rate"] = _csnd6.TREE_rate_get
    if _newclass:
        rate = _swig_property(_csnd6.TREE_rate_get, _csnd6.TREE_rate_set)
    __swig_setmethods__["len"] = _csnd6.TREE_len_set
    __swig_getmethods__["len"] = _csnd6.TREE_len_get
    if _newclass:
        len = _swig_property(_csnd6.TREE_len_get, _csnd6.TREE_len_set)
    __swig_setmethods__["line"] = _csnd6.TREE_line_set
    __swig_getmethods__["line"] = _csnd6.TREE_line_get
    if _newclass:
        line = _swig_property(_csnd6.TREE_line_get, _csnd6.TREE_line_set)
    __swig_setmethods__["locn"] = _csnd6.TREE_locn_set
    __swig_getmethods__["locn"] = _csnd6.TREE_locn_get
    if _newclass:
        locn = _swig_property(_csnd6.TREE_locn_get, _csnd6.TREE_locn_set)
    __swig_setmethods__["left"] = _csnd6.TREE_left_set
    __swig_getmethods__["left"] = _csnd6.TREE_left_get
    if _newclass:
        left = _swig_property(_csnd6.TREE_left_get, _csnd6.TREE_left_set)
    __swig_setmethods__["right"] = _csnd6.TREE_right_set
    __swig_getmethods__["right"] = _csnd6.TREE_right_get
    if _newclass:
        right = _swig_property(_csnd6.TREE_right_get, _csnd6.TREE_right_set)
    __swig_setmethods__["next"] = _csnd6.TREE_next_set
    __swig_getmethods__["next"] = _csnd6.TREE_next_get
    if _newclass:
        next = _swig_property(_csnd6.TREE_next_get, _csnd6.TREE_next_set)
    __swig_setmethods__["markup"] = _csnd6.TREE_markup_set
    __swig_getmethods__["markup"] = _csnd6.TREE_markup_get
    if _newclass:
        markup = _swig_property(_csnd6.TREE_markup_get, _csnd6.TREE_markup_set)

    def __init__(self):
        """__init__(TREE self) -> TREE"""
        this = _csnd6.new_TREE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_TREE
    __del__ = lambda self: None
TREE_swigregister = _csnd6.TREE_swigregister
TREE_swigregister(TREE)

CSOUND_CONTROL_CHANNEL = _csnd6.CSOUND_CONTROL_CHANNEL
CSOUND_AUDIO_CHANNEL = _csnd6.CSOUND_AUDIO_CHANNEL
CSOUND_STRING_CHANNEL = _csnd6.CSOUND_STRING_CHANNEL
CSOUND_PVS_CHANNEL = _csnd6.CSOUND_PVS_CHANNEL
CSOUND_VAR_CHANNEL = _csnd6.CSOUND_VAR_CHANNEL
CSOUND_CHANNEL_TYPE_MASK = _csnd6.CSOUND_CHANNEL_TYPE_MASK
CSOUND_INPUT_CHANNEL = _csnd6.CSOUND_INPUT_CHANNEL
CSOUND_OUTPUT_CHANNEL = _csnd6.CSOUND_OUTPUT_CHANNEL
CSOUND_CONTROL_CHANNEL_NO_HINTS = _csnd6.CSOUND_CONTROL_CHANNEL_NO_HINTS
CSOUND_CONTROL_CHANNEL_INT = _csnd6.CSOUND_CONTROL_CHANNEL_INT
CSOUND_CONTROL_CHANNEL_LIN = _csnd6.CSOUND_CONTROL_CHANNEL_LIN
CSOUND_CONTROL_CHANNEL_EXP = _csnd6.CSOUND_CONTROL_CHANNEL_EXP
class controlChannelHints_t(_object):
    """Proxy of C++ controlChannelHints_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, controlChannelHints_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, controlChannelHints_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["behav"] = _csnd6.controlChannelHints_t_behav_set
    __swig_getmethods__["behav"] = _csnd6.controlChannelHints_t_behav_get
    if _newclass:
        behav = _swig_property(_csnd6.controlChannelHints_t_behav_get, _csnd6.controlChannelHints_t_behav_set)
    __swig_setmethods__["dflt"] = _csnd6.controlChannelHints_t_dflt_set
    __swig_getmethods__["dflt"] = _csnd6.controlChannelHints_t_dflt_get
    if _newclass:
        dflt = _swig_property(_csnd6.controlChannelHints_t_dflt_get, _csnd6.controlChannelHints_t_dflt_set)
    __swig_setmethods__["min"] = _csnd6.controlChannelHints_t_min_set
    __swig_getmethods__["min"] = _csnd6.controlChannelHints_t_min_get
    if _newclass:
        min = _swig_property(_csnd6.controlChannelHints_t_min_get, _csnd6.controlChannelHints_t_min_set)
    __swig_setmethods__["max"] = _csnd6.controlChannelHints_t_max_set
    __swig_getmethods__["max"] = _csnd6.controlChannelHints_t_max_get
    if _newclass:
        max = _swig_property(_csnd6.controlChannelHints_t_max_get, _csnd6.controlChannelHints_t_max_set)
    __swig_setmethods__["x"] = _csnd6.controlChannelHints_t_x_set
    __swig_getmethods__["x"] = _csnd6.controlChannelHints_t_x_get
    if _newclass:
        x = _swig_property(_csnd6.controlChannelHints_t_x_get, _csnd6.controlChannelHints_t_x_set)
    __swig_setmethods__["y"] = _csnd6.controlChannelHints_t_y_set
    __swig_getmethods__["y"] = _csnd6.controlChannelHints_t_y_get
    if _newclass:
        y = _swig_property(_csnd6.controlChannelHints_t_y_get, _csnd6.controlChannelHints_t_y_set)
    __swig_setmethods__["width"] = _csnd6.controlChannelHints_t_width_set
    __swig_getmethods__["width"] = _csnd6.controlChannelHints_t_width_get
    if _newclass:
        width = _swig_property(_csnd6.controlChannelHints_t_width_get, _csnd6.controlChannelHints_t_width_set)
    __swig_setmethods__["height"] = _csnd6.controlChannelHints_t_height_set
    __swig_getmethods__["height"] = _csnd6.controlChannelHints_t_height_get
    if _newclass:
        height = _swig_property(_csnd6.controlChannelHints_t_height_get, _csnd6.controlChannelHints_t_height_set)
    __swig_setmethods__["attributes"] = _csnd6.controlChannelHints_t_attributes_set
    __swig_getmethods__["attributes"] = _csnd6.controlChannelHints_t_attributes_get
    if _newclass:
        attributes = _swig_property(_csnd6.controlChannelHints_t_attributes_get, _csnd6.controlChannelHints_t_attributes_set)

    def __init__(self):
        """__init__(controlChannelHints_s self) -> controlChannelHints_t"""
        this = _csnd6.new_controlChannelHints_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_controlChannelHints_t
    __del__ = lambda self: None
controlChannelHints_t_swigregister = _csnd6.controlChannelHints_t_swigregister
controlChannelHints_t_swigregister(controlChannelHints_t)

class controlChannelInfo_t(_object):
    """Proxy of C++ controlChannelInfo_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, controlChannelInfo_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, controlChannelInfo_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _csnd6.controlChannelInfo_t_name_set
    __swig_getmethods__["name"] = _csnd6.controlChannelInfo_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.controlChannelInfo_t_name_get, _csnd6.controlChannelInfo_t_name_set)
    __swig_setmethods__["type"] = _csnd6.controlChannelInfo_t_type_set
    __swig_getmethods__["type"] = _csnd6.controlChannelInfo_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.controlChannelInfo_t_type_get, _csnd6.controlChannelInfo_t_type_set)
    __swig_setmethods__["hints"] = _csnd6.controlChannelInfo_t_hints_set
    __swig_getmethods__["hints"] = _csnd6.controlChannelInfo_t_hints_get
    if _newclass:
        hints = _swig_property(_csnd6.controlChannelInfo_t_hints_get, _csnd6.controlChannelInfo_t_hints_set)

    def __init__(self):
        """__init__(controlChannelInfo_s self) -> controlChannelInfo_t"""
        this = _csnd6.new_controlChannelInfo_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_controlChannelInfo_t
    __del__ = lambda self: None
controlChannelInfo_t_swigregister = _csnd6.controlChannelInfo_t_swigregister
controlChannelInfo_t_swigregister(controlChannelInfo_t)


def csoundInitialize(flags):
    """csoundInitialize(int flags) -> int"""
    return _csnd6.csoundInitialize(flags)

def csoundCreate(hostData):
    """csoundCreate(void * hostData) -> CSOUND *"""
    return _csnd6.csoundCreate(hostData)

def csoundDestroy(arg1):
    """csoundDestroy(CSOUND * arg1)"""
    return _csnd6.csoundDestroy(arg1)

def csoundGetVersion():
    """csoundGetVersion() -> int"""
    return _csnd6.csoundGetVersion()

def csoundGetAPIVersion():
    """csoundGetAPIVersion() -> int"""
    return _csnd6.csoundGetAPIVersion()

def csoundParseOrc(csound, str):
    """csoundParseOrc(CSOUND * csound, char const * str) -> TREE"""
    return _csnd6.csoundParseOrc(csound, str)

def csoundCompileTree(csound, root):
    """csoundCompileTree(CSOUND * csound, TREE root) -> int"""
    return _csnd6.csoundCompileTree(csound, root)

def csoundCompileTreeAsync(csound, root):
    """csoundCompileTreeAsync(CSOUND * csound, TREE root) -> int"""
    return _csnd6.csoundCompileTreeAsync(csound, root)

def csoundDeleteTree(csound, tree):
    """csoundDeleteTree(CSOUND * csound, TREE tree)"""
    return _csnd6.csoundDeleteTree(csound, tree)

def csoundCompileOrc(csound, str):
    """csoundCompileOrc(CSOUND * csound, char const * str) -> int"""
    return _csnd6.csoundCompileOrc(csound, str)

def csoundCompileOrcAsync(csound, str):
    """csoundCompileOrcAsync(CSOUND * csound, char const * str) -> int"""
    return _csnd6.csoundCompileOrcAsync(csound, str)

def csoundEvalCode(csound, str):
    """csoundEvalCode(CSOUND * csound, char const * str) -> double"""
    return _csnd6.csoundEvalCode(csound, str)

def csoundInitializeCscore(arg1, insco, outsco):
    """csoundInitializeCscore(CSOUND * arg1, FILE * insco, FILE * outsco) -> int"""
    return _csnd6.csoundInitializeCscore(arg1, insco, outsco)

def csoundCompileArgs(arg1, argc, argv):
    """csoundCompileArgs(CSOUND * arg1, int argc, char const ** argv) -> int"""
    return _csnd6.csoundCompileArgs(arg1, argc, argv)

def csoundStart(csound):
    """csoundStart(CSOUND * csound) -> int"""
    return _csnd6.csoundStart(csound)

def csoundCompile(arg1, argc, argv):
    """csoundCompile(CSOUND * arg1, int argc, char const ** argv) -> int"""
    return _csnd6.csoundCompile(arg1, argc, argv)

def csoundCompileCsd(csound, csd_filename):
    """csoundCompileCsd(CSOUND * csound, char const * csd_filename) -> int"""
    return _csnd6.csoundCompileCsd(csound, csd_filename)

def csoundCompileCsdText(csound, csd_text):
    """csoundCompileCsdText(CSOUND * csound, char const * csd_text) -> int"""
    return _csnd6.csoundCompileCsdText(csound, csd_text)

def csoundPerform(arg1):
    """csoundPerform(CSOUND * arg1) -> int"""
    return _csnd6.csoundPerform(arg1)

def csoundPerformKsmps(arg1):
    """csoundPerformKsmps(CSOUND * arg1) -> int"""
    return _csnd6.csoundPerformKsmps(arg1)

def csoundPerformBuffer(arg1):
    """csoundPerformBuffer(CSOUND * arg1) -> int"""
    return _csnd6.csoundPerformBuffer(arg1)

def csoundStop(arg1):
    """csoundStop(CSOUND * arg1)"""
    return _csnd6.csoundStop(arg1)

def csoundCleanup(arg1):
    """csoundCleanup(CSOUND * arg1) -> int"""
    return _csnd6.csoundCleanup(arg1)

def csoundReset(arg1):
    """csoundReset(CSOUND * arg1)"""
    return _csnd6.csoundReset(arg1)

def csoundUDPServerStart(csound, port):
    """csoundUDPServerStart(CSOUND * csound, unsigned int port) -> int"""
    return _csnd6.csoundUDPServerStart(csound, port)

def csoundUDPServerStatus(csound):
    """csoundUDPServerStatus(CSOUND * csound) -> int"""
    return _csnd6.csoundUDPServerStatus(csound)

def csoundUDPServerClose(csound):
    """csoundUDPServerClose(CSOUND * csound) -> int"""
    return _csnd6.csoundUDPServerClose(csound)

def csoundUDPConsole(csound, addr, port, mirror):
    """csoundUDPConsole(CSOUND * csound, char const * addr, int port, int mirror) -> int"""
    return _csnd6.csoundUDPConsole(csound, addr, port, mirror)

def csoundStopUDPConsole(csound):
    """csoundStopUDPConsole(CSOUND * csound)"""
    return _csnd6.csoundStopUDPConsole(csound)

def csoundGetSr(arg1):
    """csoundGetSr(CSOUND * arg1) -> double"""
    return _csnd6.csoundGetSr(arg1)

def csoundGetKr(arg1):
    """csoundGetKr(CSOUND * arg1) -> double"""
    return _csnd6.csoundGetKr(arg1)

def csoundGetKsmps(arg1):
    """csoundGetKsmps(CSOUND * arg1) -> uint32_t"""
    return _csnd6.csoundGetKsmps(arg1)

def csoundGetNchnls(arg1):
    """csoundGetNchnls(CSOUND * arg1) -> uint32_t"""
    return _csnd6.csoundGetNchnls(arg1)

def csoundGetNchnlsInput(csound):
    """csoundGetNchnlsInput(CSOUND * csound) -> uint32_t"""
    return _csnd6.csoundGetNchnlsInput(csound)

def csoundGet0dBFS(arg1):
    """csoundGet0dBFS(CSOUND * arg1) -> double"""
    return _csnd6.csoundGet0dBFS(arg1)

def csoundGetA4(arg1):
    """csoundGetA4(CSOUND * arg1) -> double"""
    return _csnd6.csoundGetA4(arg1)

def csoundGetCurrentTimeSamples(csound):
    """csoundGetCurrentTimeSamples(CSOUND * csound) -> int64_t"""
    return _csnd6.csoundGetCurrentTimeSamples(csound)

def csoundGetSizeOfMYFLT():
    """csoundGetSizeOfMYFLT() -> int"""
    return _csnd6.csoundGetSizeOfMYFLT()

def csoundSetOption(csound, option):
    """csoundSetOption(CSOUND * csound, char const * option) -> int"""
    return _csnd6.csoundSetOption(csound, option)

def csoundSetParams(csound, p):
    """csoundSetParams(CSOUND * csound, CSOUND_PARAMS p)"""
    return _csnd6.csoundSetParams(csound, p)

def csoundGetParams(csound, p):
    """csoundGetParams(CSOUND * csound, CSOUND_PARAMS p)"""
    return _csnd6.csoundGetParams(csound, p)

def csoundGetDebug(arg1):
    """csoundGetDebug(CSOUND * arg1) -> int"""
    return _csnd6.csoundGetDebug(arg1)

def csoundSetDebug(arg1, debug):
    """csoundSetDebug(CSOUND * arg1, int debug)"""
    return _csnd6.csoundSetDebug(arg1, debug)

def csoundGetOutputName(arg1):
    """csoundGetOutputName(CSOUND * arg1) -> char const *"""
    return _csnd6.csoundGetOutputName(arg1)

def csoundGetInputName(arg1):
    """csoundGetInputName(CSOUND * arg1) -> char const *"""
    return _csnd6.csoundGetInputName(arg1)

def csoundSetOutput(csound, name, type, format):
    """csoundSetOutput(CSOUND * csound, char const * name, char const * type, char const * format)"""
    return _csnd6.csoundSetOutput(csound, name, type, format)

def csoundGetOutputFormat(csound, type, format):
    """csoundGetOutputFormat(CSOUND * csound, char * type, char * format)"""
    return _csnd6.csoundGetOutputFormat(csound, type, format)

def csoundSetInput(csound, name):
    """csoundSetInput(CSOUND * csound, char const * name)"""
    return _csnd6.csoundSetInput(csound, name)

def csoundSetMIDIInput(csound, name):
    """csoundSetMIDIInput(CSOUND * csound, char const * name)"""
    return _csnd6.csoundSetMIDIInput(csound, name)

def csoundSetMIDIFileInput(csound, name):
    """csoundSetMIDIFileInput(CSOUND * csound, char const * name)"""
    return _csnd6.csoundSetMIDIFileInput(csound, name)

def csoundSetMIDIOutput(csound, name):
    """csoundSetMIDIOutput(CSOUND * csound, char const * name)"""
    return _csnd6.csoundSetMIDIOutput(csound, name)

def csoundSetMIDIFileOutput(csound, name):
    """csoundSetMIDIFileOutput(CSOUND * csound, char const * name)"""
    return _csnd6.csoundSetMIDIFileOutput(csound, name)

def csoundSetRTAudioModule(csound, module):
    """csoundSetRTAudioModule(CSOUND * csound, char const * module)"""
    return _csnd6.csoundSetRTAudioModule(csound, module)

def csoundGetModule(csound, number, name, type):
    """csoundGetModule(CSOUND * csound, int number, char ** name, char ** type) -> int"""
    return _csnd6.csoundGetModule(csound, number, name, type)

def csoundGetInputBufferSize(arg1):
    """csoundGetInputBufferSize(CSOUND * arg1) -> long"""
    return _csnd6.csoundGetInputBufferSize(arg1)

def csoundGetOutputBufferSize(arg1):
    """csoundGetOutputBufferSize(CSOUND * arg1) -> long"""
    return _csnd6.csoundGetOutputBufferSize(arg1)

def csoundGetInputBuffer(arg1):
    """csoundGetInputBuffer(CSOUND * arg1) -> double *"""
    return _csnd6.csoundGetInputBuffer(arg1)

def csoundGetOutputBuffer(arg1):
    """csoundGetOutputBuffer(CSOUND * arg1) -> double *"""
    return _csnd6.csoundGetOutputBuffer(arg1)

def csoundGetSpin(arg1):
    """csoundGetSpin(CSOUND * arg1) -> double *"""
    return _csnd6.csoundGetSpin(arg1)

def csoundClearSpin(arg1):
    """csoundClearSpin(CSOUND * arg1)"""
    return _csnd6.csoundClearSpin(arg1)

def csoundAddSpinSample(csound, frame, channel, sample):
    """csoundAddSpinSample(CSOUND * csound, int frame, int channel, double sample)"""
    return _csnd6.csoundAddSpinSample(csound, frame, channel, sample)

def csoundSetSpinSample(csound, frame, channel, sample):
    """csoundSetSpinSample(CSOUND * csound, int frame, int channel, double sample)"""
    return _csnd6.csoundSetSpinSample(csound, frame, channel, sample)

def csoundGetSpout(csound):
    """csoundGetSpout(CSOUND * csound) -> double *"""
    return _csnd6.csoundGetSpout(csound)

def csoundGetSpoutSample(csound, frame, channel):
    """csoundGetSpoutSample(CSOUND * csound, int frame, int channel) -> double"""
    return _csnd6.csoundGetSpoutSample(csound, frame, channel)

def csoundGetRtRecordUserData(arg1):
    """csoundGetRtRecordUserData(CSOUND * arg1) -> void **"""
    return _csnd6.csoundGetRtRecordUserData(arg1)

def csoundGetRtPlayUserData(arg1):
    """csoundGetRtPlayUserData(CSOUND * arg1) -> void **"""
    return _csnd6.csoundGetRtPlayUserData(arg1)

def csoundSetHostImplementedAudioIO(arg1, state, bufSize):
    """csoundSetHostImplementedAudioIO(CSOUND * arg1, int state, int bufSize)"""
    return _csnd6.csoundSetHostImplementedAudioIO(arg1, state, bufSize)

def csoundGetAudioDevList(csound, list, isOutput):
    """csoundGetAudioDevList(CSOUND * csound, CS_AUDIODEVICE list, int isOutput) -> int"""
    return _csnd6.csoundGetAudioDevList(csound, list, isOutput)

def csoundSetAudioDeviceListCallback(csound, audiodevlist__):
    """csoundSetAudioDeviceListCallback(CSOUND * csound, int (*)(CSOUND *,CS_AUDIODEVICE *,int) audiodevlist__)"""
    return _csnd6.csoundSetAudioDeviceListCallback(csound, audiodevlist__)

def csoundSetMIDIModule(csound, module):
    """csoundSetMIDIModule(CSOUND * csound, char const * module)"""
    return _csnd6.csoundSetMIDIModule(csound, module)

def csoundSetHostImplementedMIDIIO(csound, state):
    """csoundSetHostImplementedMIDIIO(CSOUND * csound, int state)"""
    return _csnd6.csoundSetHostImplementedMIDIIO(csound, state)

def csoundGetMIDIDevList(csound, list, isOutput):
    """csoundGetMIDIDevList(CSOUND * csound, CS_MIDIDEVICE list, int isOutput) -> int"""
    return _csnd6.csoundGetMIDIDevList(csound, list, isOutput)

def csoundSetMIDIDeviceListCallback(csound, mididevlist__):
    """csoundSetMIDIDeviceListCallback(CSOUND * csound, int (*)(CSOUND *,CS_MIDIDEVICE *,int) mididevlist__)"""
    return _csnd6.csoundSetMIDIDeviceListCallback(csound, mididevlist__)

def csoundReadScore(csound, str):
    """csoundReadScore(CSOUND * csound, char const * str) -> int"""
    return _csnd6.csoundReadScore(csound, str)

def csoundReadScoreAsync(csound, str):
    """csoundReadScoreAsync(CSOUND * csound, char const * str)"""
    return _csnd6.csoundReadScoreAsync(csound, str)

def csoundGetScoreTime(arg1):
    """csoundGetScoreTime(CSOUND * arg1) -> double"""
    return _csnd6.csoundGetScoreTime(arg1)

def csoundIsScorePending(arg1):
    """csoundIsScorePending(CSOUND * arg1) -> int"""
    return _csnd6.csoundIsScorePending(arg1)

def csoundSetScorePending(arg1, pending):
    """csoundSetScorePending(CSOUND * arg1, int pending)"""
    return _csnd6.csoundSetScorePending(arg1, pending)

def csoundGetScoreOffsetSeconds(arg1):
    """csoundGetScoreOffsetSeconds(CSOUND * arg1) -> double"""
    return _csnd6.csoundGetScoreOffsetSeconds(arg1)

def csoundSetScoreOffsetSeconds(arg1, time):
    """csoundSetScoreOffsetSeconds(CSOUND * arg1, double time)"""
    return _csnd6.csoundSetScoreOffsetSeconds(arg1, time)

def csoundRewindScore(arg1):
    """csoundRewindScore(CSOUND * arg1)"""
    return _csnd6.csoundRewindScore(arg1)

def csoundScoreSort(arg1, inFile, outFile):
    """csoundScoreSort(CSOUND * arg1, FILE * inFile, FILE * outFile) -> int"""
    return _csnd6.csoundScoreSort(arg1, inFile, outFile)

def csoundScoreExtract(arg1, inFile, outFile, extractFile):
    """csoundScoreExtract(CSOUND * arg1, FILE * inFile, FILE * outFile, FILE * extractFile) -> int"""
    return _csnd6.csoundScoreExtract(arg1, inFile, outFile, extractFile)

def csoundMessage(arg1, format):
    """csoundMessage(CSOUND * arg1, char const * format)"""
    return _csnd6.csoundMessage(arg1, format)

def csoundMessageS(arg1, attr, format):
    """csoundMessageS(CSOUND * arg1, int attr, char const * format)"""
    return _csnd6.csoundMessageS(arg1, attr, format)

def csoundSetDefaultMessageCallback(csoundMessageCallback_):
    """csoundSetDefaultMessageCallback(void (*)(CSOUND *,int,char const *,va_list) csoundMessageCallback_)"""
    return _csnd6.csoundSetDefaultMessageCallback(csoundMessageCallback_)

def csoundSetMessageStringCallback(csound, csoundMessageStrCallback):
    """csoundSetMessageStringCallback(CSOUND * csound, void (*)(CSOUND *,int,char const *) csoundMessageStrCallback)"""
    return _csnd6.csoundSetMessageStringCallback(csound, csoundMessageStrCallback)

def csoundGetMessageLevel(arg1):
    """csoundGetMessageLevel(CSOUND * arg1) -> int"""
    return _csnd6.csoundGetMessageLevel(arg1)

def csoundSetMessageLevel(arg1, messageLevel):
    """csoundSetMessageLevel(CSOUND * arg1, int messageLevel)"""
    return _csnd6.csoundSetMessageLevel(arg1, messageLevel)

def csoundCreateMessageBuffer(csound, toStdOut):
    """csoundCreateMessageBuffer(CSOUND * csound, int toStdOut)"""
    return _csnd6.csoundCreateMessageBuffer(csound, toStdOut)

def csoundGetFirstMessage(csound):
    """csoundGetFirstMessage(CSOUND * csound) -> char const *"""
    return _csnd6.csoundGetFirstMessage(csound)

def csoundGetFirstMessageAttr(csound):
    """csoundGetFirstMessageAttr(CSOUND * csound) -> int"""
    return _csnd6.csoundGetFirstMessageAttr(csound)

def csoundPopFirstMessage(csound):
    """csoundPopFirstMessage(CSOUND * csound)"""
    return _csnd6.csoundPopFirstMessage(csound)

def csoundGetMessageCnt(csound):
    """csoundGetMessageCnt(CSOUND * csound) -> int"""
    return _csnd6.csoundGetMessageCnt(csound)

def csoundDestroyMessageBuffer(csound):
    """csoundDestroyMessageBuffer(CSOUND * csound)"""
    return _csnd6.csoundDestroyMessageBuffer(csound)

def csoundGetChannelPtr(arg1, p, name, type):
    """csoundGetChannelPtr(CSOUND * arg1, double ** p, char const * name, int type) -> int"""
    return _csnd6.csoundGetChannelPtr(arg1, p, name, type)

def csoundListChannels(arg1, lst):
    """csoundListChannels(CSOUND * arg1, controlChannelInfo_t ** lst) -> int"""
    return _csnd6.csoundListChannels(arg1, lst)

def csoundDeleteChannelList(arg1, lst):
    """csoundDeleteChannelList(CSOUND * arg1, controlChannelInfo_t lst)"""
    return _csnd6.csoundDeleteChannelList(arg1, lst)

def csoundSetControlChannelHints(arg1, name, hints):
    """csoundSetControlChannelHints(CSOUND * arg1, char const * name, controlChannelHints_t hints) -> int"""
    return _csnd6.csoundSetControlChannelHints(arg1, name, hints)

def csoundGetControlChannelHints(arg1, name, hints):
    """csoundGetControlChannelHints(CSOUND * arg1, char const * name, controlChannelHints_t hints) -> int"""
    return _csnd6.csoundGetControlChannelHints(arg1, name, hints)

def csoundGetChannelLock(arg1, name):
    """csoundGetChannelLock(CSOUND * arg1, char const * name) -> int *"""
    return _csnd6.csoundGetChannelLock(arg1, name)

def csoundGetControlChannel(csound, name, err):
    """csoundGetControlChannel(CSOUND * csound, char const * name, int * err) -> double"""
    return _csnd6.csoundGetControlChannel(csound, name, err)

def csoundSetControlChannel(csound, name, val):
    """csoundSetControlChannel(CSOUND * csound, char const * name, double val)"""
    return _csnd6.csoundSetControlChannel(csound, name, val)

def csoundGetAudioChannel(csound, name, samples):
    """csoundGetAudioChannel(CSOUND * csound, char const * name, double * samples)"""
    return _csnd6.csoundGetAudioChannel(csound, name, samples)

def csoundSetAudioChannel(csound, name, samples):
    """csoundSetAudioChannel(CSOUND * csound, char const * name, double * samples)"""
    return _csnd6.csoundSetAudioChannel(csound, name, samples)

def csoundGetStringChannel(csound, name, string):
    """csoundGetStringChannel(CSOUND * csound, char const * name, char * string)"""
    return _csnd6.csoundGetStringChannel(csound, name, string)

def csoundSetStringChannel(csound, name, string):
    """csoundSetStringChannel(CSOUND * csound, char const * name, char * string)"""
    return _csnd6.csoundSetStringChannel(csound, name, string)

def csoundGetChannelDatasize(csound, name):
    """csoundGetChannelDatasize(CSOUND * csound, char const * name) -> int"""
    return _csnd6.csoundGetChannelDatasize(csound, name)

def csoundSetInputChannelCallback(csound, inputChannelCalback):
    """csoundSetInputChannelCallback(CSOUND * csound, channelCallback_t inputChannelCalback)"""
    return _csnd6.csoundSetInputChannelCallback(csound, inputChannelCalback)

def csoundSetOutputChannelCallback(csound, outputChannelCalback):
    """csoundSetOutputChannelCallback(CSOUND * csound, channelCallback_t outputChannelCalback)"""
    return _csnd6.csoundSetOutputChannelCallback(csound, outputChannelCalback)

def csoundSetPvsChannel(arg1, fin, name):
    """csoundSetPvsChannel(CSOUND * arg1, PVSDATEXT fin, char const * name) -> int"""
    return _csnd6.csoundSetPvsChannel(arg1, fin, name)

def csoundGetPvsChannel(csound, fout, name):
    """csoundGetPvsChannel(CSOUND * csound, PVSDATEXT fout, char const * name) -> int"""
    return _csnd6.csoundGetPvsChannel(csound, fout, name)

def csoundScoreEvent(arg1, type, pFields, numFields):
    """csoundScoreEvent(CSOUND * arg1, char type, double const * pFields, long numFields) -> int"""
    return _csnd6.csoundScoreEvent(arg1, type, pFields, numFields)

def csoundScoreEventAsync(arg1, type, pFields, numFields):
    """csoundScoreEventAsync(CSOUND * arg1, char type, double const * pFields, long numFields)"""
    return _csnd6.csoundScoreEventAsync(arg1, type, pFields, numFields)

def csoundScoreEventAbsolute(arg1, type, pfields, numFields, time_ofs):
    """csoundScoreEventAbsolute(CSOUND * arg1, char type, double const * pfields, long numFields, double time_ofs) -> int"""
    return _csnd6.csoundScoreEventAbsolute(arg1, type, pfields, numFields, time_ofs)

def csoundScoreEventAbsoluteAsync(arg1, type, pfields, numFields, time_ofs):
    """csoundScoreEventAbsoluteAsync(CSOUND * arg1, char type, double const * pfields, long numFields, double time_ofs)"""
    return _csnd6.csoundScoreEventAbsoluteAsync(arg1, type, pfields, numFields, time_ofs)

def csoundInputMessage(arg1, message):
    """csoundInputMessage(CSOUND * arg1, char const * message)"""
    return _csnd6.csoundInputMessage(arg1, message)

def csoundInputMessageAsync(arg1, message):
    """csoundInputMessageAsync(CSOUND * arg1, char const * message)"""
    return _csnd6.csoundInputMessageAsync(arg1, message)

def csoundKillInstance(csound, instr, instrName, mode, allow_release):
    """csoundKillInstance(CSOUND * csound, double instr, char * instrName, int mode, int allow_release) -> int"""
    return _csnd6.csoundKillInstance(csound, instr, instrName, mode, allow_release)

def csoundKeyPress(arg1, c):
    """csoundKeyPress(CSOUND * arg1, char c)"""
    return _csnd6.csoundKeyPress(arg1, c)

def csoundRegisterKeyboardCallback(arg1, func, userData, type):
    """csoundRegisterKeyboardCallback(CSOUND * arg1, int (*)(void *,void *,unsigned int) func, void * userData, unsigned int type) -> int"""
    return _csnd6.csoundRegisterKeyboardCallback(arg1, func, userData, type)

def csoundRemoveKeyboardCallback(csound, func):
    """csoundRemoveKeyboardCallback(CSOUND * csound, int (*)(void *,void *,unsigned int) func)"""
    return _csnd6.csoundRemoveKeyboardCallback(csound, func)

def csoundTableLength(arg1, table):
    """csoundTableLength(CSOUND * arg1, int table) -> int"""
    return _csnd6.csoundTableLength(arg1, table)

def csoundTableGet(arg1, table, index):
    """csoundTableGet(CSOUND * arg1, int table, int index) -> double"""
    return _csnd6.csoundTableGet(arg1, table, index)

def csoundTableSet(arg1, table, index, value):
    """csoundTableSet(CSOUND * arg1, int table, int index, double value)"""
    return _csnd6.csoundTableSet(arg1, table, index, value)

def csoundTableCopyOut(csound, table, dest):
    """csoundTableCopyOut(CSOUND * csound, int table, double * dest)"""
    return _csnd6.csoundTableCopyOut(csound, table, dest)

def csoundTableCopyOutAsync(csound, table, dest):
    """csoundTableCopyOutAsync(CSOUND * csound, int table, double * dest)"""
    return _csnd6.csoundTableCopyOutAsync(csound, table, dest)

def csoundTableCopyIn(csound, table, src):
    """csoundTableCopyIn(CSOUND * csound, int table, double * src)"""
    return _csnd6.csoundTableCopyIn(csound, table, src)

def csoundTableCopyInAsync(csound, table, src):
    """csoundTableCopyInAsync(CSOUND * csound, int table, double * src)"""
    return _csnd6.csoundTableCopyInAsync(csound, table, src)

def csoundGetTable(arg1, tablePtr, tableNum):
    """csoundGetTable(CSOUND * arg1, double ** tablePtr, int tableNum) -> int"""
    return _csnd6.csoundGetTable(arg1, tablePtr, tableNum)

def csoundGetTableArgs(csound, argsPtr, tableNum):
    """csoundGetTableArgs(CSOUND * csound, double ** argsPtr, int tableNum) -> int"""
    return _csnd6.csoundGetTableArgs(csound, argsPtr, tableNum)

def csoundIsNamedGEN(csound, num):
    """csoundIsNamedGEN(CSOUND * csound, int num) -> int"""
    return _csnd6.csoundIsNamedGEN(csound, num)

def csoundGetNamedGEN(csound, num, name, len):
    """csoundGetNamedGEN(CSOUND * csound, int num, char * name, int len)"""
    return _csnd6.csoundGetNamedGEN(csound, num, name, len)

def csoundGetNamedGens(arg1):
    """csoundGetNamedGens(CSOUND * arg1) -> void *"""
    return _csnd6.csoundGetNamedGens(arg1)

def csoundNewOpcodeList(arg1, opcodelist):
    """csoundNewOpcodeList(CSOUND * arg1, opcodeListEntry ** opcodelist) -> int"""
    return _csnd6.csoundNewOpcodeList(arg1, opcodelist)

def csoundDisposeOpcodeList(arg1, opcodelist):
    """csoundDisposeOpcodeList(CSOUND * arg1, opcodeListEntry opcodelist)"""
    return _csnd6.csoundDisposeOpcodeList(arg1, opcodelist)

def csoundAppendOpcode(arg1, opname, dsblksiz, flags, thread, outypes, intypes, iopadr, kopadr, aopadr):
    """csoundAppendOpcode(CSOUND * arg1, char const * opname, int dsblksiz, int flags, int thread, char const * outypes, char const * intypes, int (*)(CSOUND *,void *) iopadr, int (*)(CSOUND *,void *) kopadr, int (*)(CSOUND *,void *) aopadr) -> int"""
    return _csnd6.csoundAppendOpcode(arg1, opname, dsblksiz, flags, thread, outypes, intypes, iopadr, kopadr, aopadr)

def csoundCreateThread(threadRoutine, userdata):
    """csoundCreateThread(uintptr_t (*)(void *) threadRoutine, void * userdata) -> void *"""
    return _csnd6.csoundCreateThread(threadRoutine, userdata)

def csoundGetCurrentThreadId():
    """csoundGetCurrentThreadId() -> void *"""
    return _csnd6.csoundGetCurrentThreadId()

def csoundJoinThread(thread):
    """csoundJoinThread(void * thread) -> uintptr_t"""
    return _csnd6.csoundJoinThread(thread)

def csoundCreateThreadLock():
    """csoundCreateThreadLock() -> void *"""
    return _csnd6.csoundCreateThreadLock()

def csoundWaitThreadLock(lock, milliseconds):
    """csoundWaitThreadLock(void * lock, size_t milliseconds) -> int"""
    return _csnd6.csoundWaitThreadLock(lock, milliseconds)

def csoundWaitThreadLockNoTimeout(lock):
    """csoundWaitThreadLockNoTimeout(void * lock)"""
    return _csnd6.csoundWaitThreadLockNoTimeout(lock)

def csoundNotifyThreadLock(lock):
    """csoundNotifyThreadLock(void * lock)"""
    return _csnd6.csoundNotifyThreadLock(lock)

def csoundDestroyThreadLock(lock):
    """csoundDestroyThreadLock(void * lock)"""
    return _csnd6.csoundDestroyThreadLock(lock)

def csoundCreateMutex(isRecursive):
    """csoundCreateMutex(int isRecursive) -> void *"""
    return _csnd6.csoundCreateMutex(isRecursive)

def csoundLockMutex(mutex_):
    """csoundLockMutex(void * mutex_)"""
    return _csnd6.csoundLockMutex(mutex_)

def csoundLockMutexNoWait(mutex_):
    """csoundLockMutexNoWait(void * mutex_) -> int"""
    return _csnd6.csoundLockMutexNoWait(mutex_)

def csoundUnlockMutex(mutex_):
    """csoundUnlockMutex(void * mutex_)"""
    return _csnd6.csoundUnlockMutex(mutex_)

def csoundDestroyMutex(mutex_):
    """csoundDestroyMutex(void * mutex_)"""
    return _csnd6.csoundDestroyMutex(mutex_)

def csoundCreateBarrier(max):
    """csoundCreateBarrier(unsigned int max) -> void *"""
    return _csnd6.csoundCreateBarrier(max)

def csoundDestroyBarrier(barrier):
    """csoundDestroyBarrier(void * barrier) -> int"""
    return _csnd6.csoundDestroyBarrier(barrier)

def csoundWaitBarrier(barrier):
    """csoundWaitBarrier(void * barrier) -> int"""
    return _csnd6.csoundWaitBarrier(barrier)

def csoundCreateCondVar():
    """csoundCreateCondVar() -> void *"""
    return _csnd6.csoundCreateCondVar()

def csoundCondWait(condVar, mutex):
    """csoundCondWait(void * condVar, void * mutex)"""
    return _csnd6.csoundCondWait(condVar, mutex)

def csoundCondSignal(condVar):
    """csoundCondSignal(void * condVar)"""
    return _csnd6.csoundCondSignal(condVar)

def csoundSleep(milliseconds):
    """csoundSleep(size_t milliseconds)"""
    return _csnd6.csoundSleep(milliseconds)

def csoundSpinLockInit(spinlock):
    """csoundSpinLockInit(spin_lock_t * spinlock) -> int"""
    return _csnd6.csoundSpinLockInit(spinlock)

def csoundSpinLock(spinlock):
    """csoundSpinLock(spin_lock_t * spinlock)"""
    return _csnd6.csoundSpinLock(spinlock)

def csoundSpinTryLock(spinlock):
    """csoundSpinTryLock(spin_lock_t * spinlock) -> int"""
    return _csnd6.csoundSpinTryLock(spinlock)

def csoundSpinUnLock(spinlock):
    """csoundSpinUnLock(spin_lock_t * spinlock)"""
    return _csnd6.csoundSpinUnLock(spinlock)

def csoundRunCommand(argv, noWait):
    """csoundRunCommand(char const *const * argv, int noWait) -> long"""
    return _csnd6.csoundRunCommand(argv, noWait)

def csoundInitTimerStruct(arg1):
    """csoundInitTimerStruct(RTCLOCK arg1)"""
    return _csnd6.csoundInitTimerStruct(arg1)

def csoundGetRealTime(arg1):
    """csoundGetRealTime(RTCLOCK arg1) -> double"""
    return _csnd6.csoundGetRealTime(arg1)

def csoundGetCPUTime(arg1):
    """csoundGetCPUTime(RTCLOCK arg1) -> double"""
    return _csnd6.csoundGetCPUTime(arg1)

def csoundGetRandomSeedFromTime():
    """csoundGetRandomSeedFromTime() -> uint32_t"""
    return _csnd6.csoundGetRandomSeedFromTime()

def csoundSetLanguage(lang_code):
    """csoundSetLanguage(cslanguage_t lang_code)"""
    return _csnd6.csoundSetLanguage(lang_code)

def csoundGetEnv(csound, name):
    """csoundGetEnv(CSOUND * csound, char const * name) -> char const *"""
    return _csnd6.csoundGetEnv(csound, name)

def csoundSetGlobalEnv(name, value):
    """csoundSetGlobalEnv(char const * name, char const * value) -> int"""
    return _csnd6.csoundSetGlobalEnv(name, value)

def csoundCreateGlobalVariable(arg1, name, nbytes):
    """csoundCreateGlobalVariable(CSOUND * arg1, char const * name, size_t nbytes) -> int"""
    return _csnd6.csoundCreateGlobalVariable(arg1, name, nbytes)

def csoundQueryGlobalVariable(arg1, name):
    """csoundQueryGlobalVariable(CSOUND * arg1, char const * name) -> void *"""
    return _csnd6.csoundQueryGlobalVariable(arg1, name)

def csoundQueryGlobalVariableNoCheck(arg1, name):
    """csoundQueryGlobalVariableNoCheck(CSOUND * arg1, char const * name) -> void *"""
    return _csnd6.csoundQueryGlobalVariableNoCheck(arg1, name)

def csoundDestroyGlobalVariable(arg1, name):
    """csoundDestroyGlobalVariable(CSOUND * arg1, char const * name) -> int"""
    return _csnd6.csoundDestroyGlobalVariable(arg1, name)

def csoundRunUtility(arg1, name, argc, argv):
    """csoundRunUtility(CSOUND * arg1, char const * name, int argc, char ** argv) -> int"""
    return _csnd6.csoundRunUtility(arg1, name, argc, argv)

def csoundListUtilities(arg1):
    """csoundListUtilities(CSOUND * arg1) -> char **"""
    return _csnd6.csoundListUtilities(arg1)

def csoundDeleteUtilityList(arg1, lst):
    """csoundDeleteUtilityList(CSOUND * arg1, char ** lst)"""
    return _csnd6.csoundDeleteUtilityList(arg1, lst)

def csoundGetUtilityDescription(arg1, utilName):
    """csoundGetUtilityDescription(CSOUND * arg1, char const * utilName) -> char const *"""
    return _csnd6.csoundGetUtilityDescription(arg1, utilName)

def csoundRand31(seedVal):
    """csoundRand31(int * seedVal) -> int"""
    return _csnd6.csoundRand31(seedVal)

def csoundSeedRandMT(p, initKey, keyLength):
    """csoundSeedRandMT(CsoundRandMTState p, uint32_t const * initKey, uint32_t keyLength)"""
    return _csnd6.csoundSeedRandMT(p, initKey, keyLength)

def csoundRandMT(p):
    """csoundRandMT(CsoundRandMTState p) -> uint32_t"""
    return _csnd6.csoundRandMT(p)
class csCfgVariableHead_t(_object):
    """Proxy of C++ csCfgVariableHead_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableHead_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableHead_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableHead_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableHead_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableHead_t_nxt_get, _csnd6.csCfgVariableHead_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableHead_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableHead_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableHead_t_name_get, _csnd6.csCfgVariableHead_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableHead_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableHead_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableHead_t_p_get, _csnd6.csCfgVariableHead_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableHead_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableHead_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableHead_t_type_get, _csnd6.csCfgVariableHead_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableHead_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableHead_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableHead_t_flags_get, _csnd6.csCfgVariableHead_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableHead_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableHead_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableHead_t_shortDesc_get, _csnd6.csCfgVariableHead_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableHead_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableHead_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableHead_t_longDesc_get, _csnd6.csCfgVariableHead_t_longDesc_set)

    def __init__(self):
        """__init__(csCfgVariableHead_s self) -> csCfgVariableHead_t"""
        this = _csnd6.new_csCfgVariableHead_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableHead_t
    __del__ = lambda self: None
csCfgVariableHead_t_swigregister = _csnd6.csCfgVariableHead_t_swigregister
csCfgVariableHead_t_swigregister(csCfgVariableHead_t)

class csCfgVariableInt_t(_object):
    """Proxy of C++ csCfgVariableInt_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableInt_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableInt_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableInt_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableInt_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableInt_t_nxt_get, _csnd6.csCfgVariableInt_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableInt_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableInt_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableInt_t_name_get, _csnd6.csCfgVariableInt_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableInt_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableInt_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableInt_t_p_get, _csnd6.csCfgVariableInt_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableInt_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableInt_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableInt_t_type_get, _csnd6.csCfgVariableInt_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableInt_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableInt_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableInt_t_flags_get, _csnd6.csCfgVariableInt_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableInt_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableInt_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableInt_t_shortDesc_get, _csnd6.csCfgVariableInt_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableInt_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableInt_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableInt_t_longDesc_get, _csnd6.csCfgVariableInt_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd6.csCfgVariableInt_t_min_set
    __swig_getmethods__["min"] = _csnd6.csCfgVariableInt_t_min_get
    if _newclass:
        min = _swig_property(_csnd6.csCfgVariableInt_t_min_get, _csnd6.csCfgVariableInt_t_min_set)
    __swig_setmethods__["max"] = _csnd6.csCfgVariableInt_t_max_set
    __swig_getmethods__["max"] = _csnd6.csCfgVariableInt_t_max_get
    if _newclass:
        max = _swig_property(_csnd6.csCfgVariableInt_t_max_get, _csnd6.csCfgVariableInt_t_max_set)

    def __init__(self):
        """__init__(csCfgVariableInt_s self) -> csCfgVariableInt_t"""
        this = _csnd6.new_csCfgVariableInt_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableInt_t
    __del__ = lambda self: None
csCfgVariableInt_t_swigregister = _csnd6.csCfgVariableInt_t_swigregister
csCfgVariableInt_t_swigregister(csCfgVariableInt_t)

class csCfgVariableBoolean_t(_object):
    """Proxy of C++ csCfgVariableBoolean_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableBoolean_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableBoolean_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableBoolean_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableBoolean_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableBoolean_t_nxt_get, _csnd6.csCfgVariableBoolean_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableBoolean_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableBoolean_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableBoolean_t_name_get, _csnd6.csCfgVariableBoolean_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableBoolean_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableBoolean_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableBoolean_t_p_get, _csnd6.csCfgVariableBoolean_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableBoolean_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableBoolean_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableBoolean_t_type_get, _csnd6.csCfgVariableBoolean_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableBoolean_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableBoolean_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableBoolean_t_flags_get, _csnd6.csCfgVariableBoolean_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableBoolean_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableBoolean_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableBoolean_t_shortDesc_get, _csnd6.csCfgVariableBoolean_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableBoolean_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableBoolean_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableBoolean_t_longDesc_get, _csnd6.csCfgVariableBoolean_t_longDesc_set)

    def __init__(self):
        """__init__(csCfgVariableBoolean_s self) -> csCfgVariableBoolean_t"""
        this = _csnd6.new_csCfgVariableBoolean_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableBoolean_t
    __del__ = lambda self: None
csCfgVariableBoolean_t_swigregister = _csnd6.csCfgVariableBoolean_t_swigregister
csCfgVariableBoolean_t_swigregister(csCfgVariableBoolean_t)

class csCfgVariableFloat_t(_object):
    """Proxy of C++ csCfgVariableFloat_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableFloat_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableFloat_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableFloat_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableFloat_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableFloat_t_nxt_get, _csnd6.csCfgVariableFloat_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableFloat_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableFloat_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableFloat_t_name_get, _csnd6.csCfgVariableFloat_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableFloat_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableFloat_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableFloat_t_p_get, _csnd6.csCfgVariableFloat_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableFloat_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableFloat_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableFloat_t_type_get, _csnd6.csCfgVariableFloat_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableFloat_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableFloat_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableFloat_t_flags_get, _csnd6.csCfgVariableFloat_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableFloat_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableFloat_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableFloat_t_shortDesc_get, _csnd6.csCfgVariableFloat_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableFloat_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableFloat_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableFloat_t_longDesc_get, _csnd6.csCfgVariableFloat_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd6.csCfgVariableFloat_t_min_set
    __swig_getmethods__["min"] = _csnd6.csCfgVariableFloat_t_min_get
    if _newclass:
        min = _swig_property(_csnd6.csCfgVariableFloat_t_min_get, _csnd6.csCfgVariableFloat_t_min_set)
    __swig_setmethods__["max"] = _csnd6.csCfgVariableFloat_t_max_set
    __swig_getmethods__["max"] = _csnd6.csCfgVariableFloat_t_max_get
    if _newclass:
        max = _swig_property(_csnd6.csCfgVariableFloat_t_max_get, _csnd6.csCfgVariableFloat_t_max_set)

    def __init__(self):
        """__init__(csCfgVariableFloat_s self) -> csCfgVariableFloat_t"""
        this = _csnd6.new_csCfgVariableFloat_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableFloat_t
    __del__ = lambda self: None
csCfgVariableFloat_t_swigregister = _csnd6.csCfgVariableFloat_t_swigregister
csCfgVariableFloat_t_swigregister(csCfgVariableFloat_t)

class csCfgVariableDouble_t(_object):
    """Proxy of C++ csCfgVariableDouble_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableDouble_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableDouble_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableDouble_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableDouble_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableDouble_t_nxt_get, _csnd6.csCfgVariableDouble_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableDouble_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableDouble_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableDouble_t_name_get, _csnd6.csCfgVariableDouble_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableDouble_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableDouble_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableDouble_t_p_get, _csnd6.csCfgVariableDouble_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableDouble_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableDouble_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableDouble_t_type_get, _csnd6.csCfgVariableDouble_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableDouble_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableDouble_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableDouble_t_flags_get, _csnd6.csCfgVariableDouble_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableDouble_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableDouble_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableDouble_t_shortDesc_get, _csnd6.csCfgVariableDouble_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableDouble_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableDouble_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableDouble_t_longDesc_get, _csnd6.csCfgVariableDouble_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd6.csCfgVariableDouble_t_min_set
    __swig_getmethods__["min"] = _csnd6.csCfgVariableDouble_t_min_get
    if _newclass:
        min = _swig_property(_csnd6.csCfgVariableDouble_t_min_get, _csnd6.csCfgVariableDouble_t_min_set)
    __swig_setmethods__["max"] = _csnd6.csCfgVariableDouble_t_max_set
    __swig_getmethods__["max"] = _csnd6.csCfgVariableDouble_t_max_get
    if _newclass:
        max = _swig_property(_csnd6.csCfgVariableDouble_t_max_get, _csnd6.csCfgVariableDouble_t_max_set)

    def __init__(self):
        """__init__(csCfgVariableDouble_s self) -> csCfgVariableDouble_t"""
        this = _csnd6.new_csCfgVariableDouble_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableDouble_t
    __del__ = lambda self: None
csCfgVariableDouble_t_swigregister = _csnd6.csCfgVariableDouble_t_swigregister
csCfgVariableDouble_t_swigregister(csCfgVariableDouble_t)

class csCfgVariableMYFLT_t(_object):
    """Proxy of C++ csCfgVariableMYFLT_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableMYFLT_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableMYFLT_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableMYFLT_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableMYFLT_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableMYFLT_t_nxt_get, _csnd6.csCfgVariableMYFLT_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableMYFLT_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableMYFLT_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableMYFLT_t_name_get, _csnd6.csCfgVariableMYFLT_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableMYFLT_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableMYFLT_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableMYFLT_t_p_get, _csnd6.csCfgVariableMYFLT_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableMYFLT_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableMYFLT_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableMYFLT_t_type_get, _csnd6.csCfgVariableMYFLT_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableMYFLT_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableMYFLT_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableMYFLT_t_flags_get, _csnd6.csCfgVariableMYFLT_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableMYFLT_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableMYFLT_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableMYFLT_t_shortDesc_get, _csnd6.csCfgVariableMYFLT_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableMYFLT_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableMYFLT_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableMYFLT_t_longDesc_get, _csnd6.csCfgVariableMYFLT_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd6.csCfgVariableMYFLT_t_min_set
    __swig_getmethods__["min"] = _csnd6.csCfgVariableMYFLT_t_min_get
    if _newclass:
        min = _swig_property(_csnd6.csCfgVariableMYFLT_t_min_get, _csnd6.csCfgVariableMYFLT_t_min_set)
    __swig_setmethods__["max"] = _csnd6.csCfgVariableMYFLT_t_max_set
    __swig_getmethods__["max"] = _csnd6.csCfgVariableMYFLT_t_max_get
    if _newclass:
        max = _swig_property(_csnd6.csCfgVariableMYFLT_t_max_get, _csnd6.csCfgVariableMYFLT_t_max_set)

    def __init__(self):
        """__init__(csCfgVariableMYFLT_s self) -> csCfgVariableMYFLT_t"""
        this = _csnd6.new_csCfgVariableMYFLT_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableMYFLT_t
    __del__ = lambda self: None
csCfgVariableMYFLT_t_swigregister = _csnd6.csCfgVariableMYFLT_t_swigregister
csCfgVariableMYFLT_t_swigregister(csCfgVariableMYFLT_t)

class csCfgVariableString_t(_object):
    """Proxy of C++ csCfgVariableString_s class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableString_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableString_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _csnd6.csCfgVariableString_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd6.csCfgVariableString_t_nxt_get
    if _newclass:
        nxt = _swig_property(_csnd6.csCfgVariableString_t_nxt_get, _csnd6.csCfgVariableString_t_nxt_set)
    __swig_setmethods__["name"] = _csnd6.csCfgVariableString_t_name_set
    __swig_getmethods__["name"] = _csnd6.csCfgVariableString_t_name_get
    if _newclass:
        name = _swig_property(_csnd6.csCfgVariableString_t_name_get, _csnd6.csCfgVariableString_t_name_set)
    __swig_setmethods__["p"] = _csnd6.csCfgVariableString_t_p_set
    __swig_getmethods__["p"] = _csnd6.csCfgVariableString_t_p_get
    if _newclass:
        p = _swig_property(_csnd6.csCfgVariableString_t_p_get, _csnd6.csCfgVariableString_t_p_set)
    __swig_setmethods__["type"] = _csnd6.csCfgVariableString_t_type_set
    __swig_getmethods__["type"] = _csnd6.csCfgVariableString_t_type_get
    if _newclass:
        type = _swig_property(_csnd6.csCfgVariableString_t_type_get, _csnd6.csCfgVariableString_t_type_set)
    __swig_setmethods__["flags"] = _csnd6.csCfgVariableString_t_flags_set
    __swig_getmethods__["flags"] = _csnd6.csCfgVariableString_t_flags_get
    if _newclass:
        flags = _swig_property(_csnd6.csCfgVariableString_t_flags_get, _csnd6.csCfgVariableString_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd6.csCfgVariableString_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd6.csCfgVariableString_t_shortDesc_get
    if _newclass:
        shortDesc = _swig_property(_csnd6.csCfgVariableString_t_shortDesc_get, _csnd6.csCfgVariableString_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd6.csCfgVariableString_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd6.csCfgVariableString_t_longDesc_get
    if _newclass:
        longDesc = _swig_property(_csnd6.csCfgVariableString_t_longDesc_get, _csnd6.csCfgVariableString_t_longDesc_set)
    __swig_setmethods__["maxlen"] = _csnd6.csCfgVariableString_t_maxlen_set
    __swig_getmethods__["maxlen"] = _csnd6.csCfgVariableString_t_maxlen_get
    if _newclass:
        maxlen = _swig_property(_csnd6.csCfgVariableString_t_maxlen_get, _csnd6.csCfgVariableString_t_maxlen_set)

    def __init__(self):
        """__init__(csCfgVariableString_s self) -> csCfgVariableString_t"""
        this = _csnd6.new_csCfgVariableString_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariableString_t
    __del__ = lambda self: None
csCfgVariableString_t_swigregister = _csnd6.csCfgVariableString_t_swigregister
csCfgVariableString_t_swigregister(csCfgVariableString_t)

class csCfgVariable_t(_object):
    """Proxy of C++ csCfgVariable_u class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariable_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariable_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["h"] = _csnd6.csCfgVariable_t_h_set
    __swig_getmethods__["h"] = _csnd6.csCfgVariable_t_h_get
    if _newclass:
        h = _swig_property(_csnd6.csCfgVariable_t_h_get, _csnd6.csCfgVariable_t_h_set)
    __swig_setmethods__["i"] = _csnd6.csCfgVariable_t_i_set
    __swig_getmethods__["i"] = _csnd6.csCfgVariable_t_i_get
    if _newclass:
        i = _swig_property(_csnd6.csCfgVariable_t_i_get, _csnd6.csCfgVariable_t_i_set)
    __swig_setmethods__["b"] = _csnd6.csCfgVariable_t_b_set
    __swig_getmethods__["b"] = _csnd6.csCfgVariable_t_b_get
    if _newclass:
        b = _swig_property(_csnd6.csCfgVariable_t_b_get, _csnd6.csCfgVariable_t_b_set)
    __swig_setmethods__["f"] = _csnd6.csCfgVariable_t_f_set
    __swig_getmethods__["f"] = _csnd6.csCfgVariable_t_f_get
    if _newclass:
        f = _swig_property(_csnd6.csCfgVariable_t_f_get, _csnd6.csCfgVariable_t_f_set)
    __swig_setmethods__["d"] = _csnd6.csCfgVariable_t_d_set
    __swig_getmethods__["d"] = _csnd6.csCfgVariable_t_d_get
    if _newclass:
        d = _swig_property(_csnd6.csCfgVariable_t_d_get, _csnd6.csCfgVariable_t_d_set)
    __swig_setmethods__["m"] = _csnd6.csCfgVariable_t_m_set
    __swig_getmethods__["m"] = _csnd6.csCfgVariable_t_m_get
    if _newclass:
        m = _swig_property(_csnd6.csCfgVariable_t_m_get, _csnd6.csCfgVariable_t_m_set)
    __swig_setmethods__["s"] = _csnd6.csCfgVariable_t_s_set
    __swig_getmethods__["s"] = _csnd6.csCfgVariable_t_s_get
    if _newclass:
        s = _swig_property(_csnd6.csCfgVariable_t_s_get, _csnd6.csCfgVariable_t_s_set)

    def __init__(self):
        """__init__(csCfgVariable_u self) -> csCfgVariable_t"""
        this = _csnd6.new_csCfgVariable_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_csCfgVariable_t
    __del__ = lambda self: None
csCfgVariable_t_swigregister = _csnd6.csCfgVariable_t_swigregister
csCfgVariable_t_swigregister(csCfgVariable_t)

CSOUNDCFG_INTEGER = _csnd6.CSOUNDCFG_INTEGER
CSOUNDCFG_BOOLEAN = _csnd6.CSOUNDCFG_BOOLEAN
CSOUNDCFG_FLOAT = _csnd6.CSOUNDCFG_FLOAT
CSOUNDCFG_DOUBLE = _csnd6.CSOUNDCFG_DOUBLE
CSOUNDCFG_MYFLT = _csnd6.CSOUNDCFG_MYFLT
CSOUNDCFG_STRING = _csnd6.CSOUNDCFG_STRING
CSOUNDCFG_POWOFTWO = _csnd6.CSOUNDCFG_POWOFTWO
CSOUNDCFG_SUCCESS = _csnd6.CSOUNDCFG_SUCCESS
CSOUNDCFG_INVALID_NAME = _csnd6.CSOUNDCFG_INVALID_NAME
CSOUNDCFG_INVALID_TYPE = _csnd6.CSOUNDCFG_INVALID_TYPE
CSOUNDCFG_INVALID_FLAG = _csnd6.CSOUNDCFG_INVALID_FLAG
CSOUNDCFG_NULL_POINTER = _csnd6.CSOUNDCFG_NULL_POINTER
CSOUNDCFG_TOO_HIGH = _csnd6.CSOUNDCFG_TOO_HIGH
CSOUNDCFG_TOO_LOW = _csnd6.CSOUNDCFG_TOO_LOW
CSOUNDCFG_NOT_POWOFTWO = _csnd6.CSOUNDCFG_NOT_POWOFTWO
CSOUNDCFG_INVALID_BOOLEAN = _csnd6.CSOUNDCFG_INVALID_BOOLEAN
CSOUNDCFG_MEMORY = _csnd6.CSOUNDCFG_MEMORY
CSOUNDCFG_STRING_LENGTH = _csnd6.CSOUNDCFG_STRING_LENGTH
CSOUNDCFG_LASTERROR = _csnd6.CSOUNDCFG_LASTERROR

def csoundCreateConfigurationVariable(csound, name, p, type, flags, min, max, shortDesc, longDesc):
    """csoundCreateConfigurationVariable(CSOUND * csound, char const * name, void * p, int type, int flags, void * min, void * max, char const * shortDesc, char const * longDesc) -> int"""
    return _csnd6.csoundCreateConfigurationVariable(csound, name, p, type, flags, min, max, shortDesc, longDesc)

def csoundSetConfigurationVariable(csound, name, value):
    """csoundSetConfigurationVariable(CSOUND * csound, char const * name, void * value) -> int"""
    return _csnd6.csoundSetConfigurationVariable(csound, name, value)

def csoundParseConfigurationVariable(csound, name, value):
    """csoundParseConfigurationVariable(CSOUND * csound, char const * name, char const * value) -> int"""
    return _csnd6.csoundParseConfigurationVariable(csound, name, value)

def csoundQueryConfigurationVariable(csound, name):
    """csoundQueryConfigurationVariable(CSOUND * csound, char const * name) -> csCfgVariable_t"""
    return _csnd6.csoundQueryConfigurationVariable(csound, name)

def csoundListConfigurationVariables(csound):
    """csoundListConfigurationVariables(CSOUND * csound) -> csCfgVariable_t **"""
    return _csnd6.csoundListConfigurationVariables(csound)

def csoundDeleteCfgVarList(csound, lst):
    """csoundDeleteCfgVarList(CSOUND * csound, csCfgVariable_t ** lst)"""
    return _csnd6.csoundDeleteCfgVarList(csound, lst)

def csoundDeleteConfigurationVariable(csound, name):
    """csoundDeleteConfigurationVariable(CSOUND * csound, char const * name) -> int"""
    return _csnd6.csoundDeleteConfigurationVariable(csound, name)

def csoundCfgErrorCodeToString(errcode):
    """csoundCfgErrorCodeToString(int errcode) -> char const *"""
    return _csnd6.csoundCfgErrorCodeToString(errcode)
CSOUNDMSG_DEFAULT = _csnd6.CSOUNDMSG_DEFAULT
CSOUNDMSG_ERROR = _csnd6.CSOUNDMSG_ERROR
CSOUNDMSG_ORCH = _csnd6.CSOUNDMSG_ORCH
CSOUNDMSG_REALTIME = _csnd6.CSOUNDMSG_REALTIME
CSOUNDMSG_WARNING = _csnd6.CSOUNDMSG_WARNING
CSOUNDMSG_STDOUT = _csnd6.CSOUNDMSG_STDOUT
CSOUNDMSG_FG_BLACK = _csnd6.CSOUNDMSG_FG_BLACK
CSOUNDMSG_FG_RED = _csnd6.CSOUNDMSG_FG_RED
CSOUNDMSG_FG_GREEN = _csnd6.CSOUNDMSG_FG_GREEN
CSOUNDMSG_FG_YELLOW = _csnd6.CSOUNDMSG_FG_YELLOW
CSOUNDMSG_FG_BLUE = _csnd6.CSOUNDMSG_FG_BLUE
CSOUNDMSG_FG_MAGENTA = _csnd6.CSOUNDMSG_FG_MAGENTA
CSOUNDMSG_FG_CYAN = _csnd6.CSOUNDMSG_FG_CYAN
CSOUNDMSG_FG_WHITE = _csnd6.CSOUNDMSG_FG_WHITE
CSOUNDMSG_FG_BOLD = _csnd6.CSOUNDMSG_FG_BOLD
CSOUNDMSG_FG_UNDERLINE = _csnd6.CSOUNDMSG_FG_UNDERLINE
CSOUNDMSG_BG_BLACK = _csnd6.CSOUNDMSG_BG_BLACK
CSOUNDMSG_BG_RED = _csnd6.CSOUNDMSG_BG_RED
CSOUNDMSG_BG_GREEN = _csnd6.CSOUNDMSG_BG_GREEN
CSOUNDMSG_BG_ORANGE = _csnd6.CSOUNDMSG_BG_ORANGE
CSOUNDMSG_BG_BLUE = _csnd6.CSOUNDMSG_BG_BLUE
CSOUNDMSG_BG_MAGENTA = _csnd6.CSOUNDMSG_BG_MAGENTA
CSOUNDMSG_BG_CYAN = _csnd6.CSOUNDMSG_BG_CYAN
CSOUNDMSG_BG_GREY = _csnd6.CSOUNDMSG_BG_GREY
CSOUNDMSG_TYPE_MASK = _csnd6.CSOUNDMSG_TYPE_MASK
CSOUNDMSG_FG_COLOR_MASK = _csnd6.CSOUNDMSG_FG_COLOR_MASK
CSOUNDMSG_FG_ATTR_MASK = _csnd6.CSOUNDMSG_FG_ATTR_MASK
CSOUNDMSG_BG_COLOR_MASK = _csnd6.CSOUNDMSG_BG_COLOR_MASK
VERSION = _csnd6.VERSION
CS_PACKAGE_NAME = _csnd6.CS_PACKAGE_NAME
CS_PACKAGE_STRING = _csnd6.CS_PACKAGE_STRING
CS_PACKAGE_TARNAME = _csnd6.CS_PACKAGE_TARNAME
CS_PACKAGE_VERSION = _csnd6.CS_PACKAGE_VERSION
CS_VERSION = _csnd6.CS_VERSION
CS_SUBVER = _csnd6.CS_SUBVER
CS_PATCHLEVEL = _csnd6.CS_PATCHLEVEL
CS_APIVERSION = _csnd6.CS_APIVERSION
CS_APISUBVER = _csnd6.CS_APISUBVER

def csoundCreateCircularBuffer(csound, numelem, elemsize):
    """csoundCreateCircularBuffer(CSOUND * csound, int numelem, int elemsize) -> void *"""
    return _csnd6.csoundCreateCircularBuffer(csound, numelem, elemsize)

def csoundReadCircularBuffer(csound, circular_buffer, out, items):
    """csoundReadCircularBuffer(CSOUND * csound, void * circular_buffer, void * out, int items) -> int"""
    return _csnd6.csoundReadCircularBuffer(csound, circular_buffer, out, items)

def csoundPeekCircularBuffer(csound, circular_buffer, out, items):
    """csoundPeekCircularBuffer(CSOUND * csound, void * circular_buffer, void * out, int items) -> int"""
    return _csnd6.csoundPeekCircularBuffer(csound, circular_buffer, out, items)

def csoundWriteCircularBuffer(csound, p, inp, items):
    """csoundWriteCircularBuffer(CSOUND * csound, void * p, void const * inp, int items) -> int"""
    return _csnd6.csoundWriteCircularBuffer(csound, p, inp, items)

def csoundFlushCircularBuffer(csound, p):
    """csoundFlushCircularBuffer(CSOUND * csound, void * p)"""
    return _csnd6.csoundFlushCircularBuffer(csound, p)

def csoundDestroyCircularBuffer(csound, circularbuffer):
    """csoundDestroyCircularBuffer(CSOUND * csound, void * circularbuffer)"""
    return _csnd6.csoundDestroyCircularBuffer(csound, circularbuffer)

def csoundOpenLibrary(library, libraryPath):
    """csoundOpenLibrary(void ** library, char const * libraryPath) -> int"""
    return _csnd6.csoundOpenLibrary(library, libraryPath)

def csoundCloseLibrary(library):
    """csoundCloseLibrary(void * library) -> int"""
    return _csnd6.csoundCloseLibrary(library)

def csoundGetLibrarySymbol(library, symbolName):
    """csoundGetLibrarySymbol(void * library, char const * symbolName) -> void *"""
    return _csnd6.csoundGetLibrarySymbol(library, symbolName)

def csoundGetInstance(obj):
    """csoundGetInstance(int64_t obj) -> CSOUND *"""
    return _csnd6.csoundGetInstance(obj)
MESSAGE_BUFFER_LENGTH = _csnd6.MESSAGE_BUFFER_LENGTH
class pycbdata(_object):
    """Proxy of C++ pycbdata class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pycbdata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pycbdata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mfunc"] = _csnd6.pycbdata_mfunc_set
    __swig_getmethods__["mfunc"] = _csnd6.pycbdata_mfunc_get
    if _newclass:
        mfunc = _swig_property(_csnd6.pycbdata_mfunc_get, _csnd6.pycbdata_mfunc_set)
    __swig_setmethods__["invalfunc"] = _csnd6.pycbdata_invalfunc_set
    __swig_getmethods__["invalfunc"] = _csnd6.pycbdata_invalfunc_get
    if _newclass:
        invalfunc = _swig_property(_csnd6.pycbdata_invalfunc_get, _csnd6.pycbdata_invalfunc_set)
    __swig_setmethods__["outvalfunc"] = _csnd6.pycbdata_outvalfunc_set
    __swig_getmethods__["outvalfunc"] = _csnd6.pycbdata_outvalfunc_get
    if _newclass:
        outvalfunc = _swig_property(_csnd6.pycbdata_outvalfunc_get, _csnd6.pycbdata_outvalfunc_set)
    __swig_setmethods__["midiinopenfunc"] = _csnd6.pycbdata_midiinopenfunc_set
    __swig_getmethods__["midiinopenfunc"] = _csnd6.pycbdata_midiinopenfunc_get
    if _newclass:
        midiinopenfunc = _swig_property(_csnd6.pycbdata_midiinopenfunc_get, _csnd6.pycbdata_midiinopenfunc_set)
    __swig_setmethods__["midireadfunc"] = _csnd6.pycbdata_midireadfunc_set
    __swig_getmethods__["midireadfunc"] = _csnd6.pycbdata_midireadfunc_get
    if _newclass:
        midireadfunc = _swig_property(_csnd6.pycbdata_midireadfunc_get, _csnd6.pycbdata_midireadfunc_set)
    __swig_setmethods__["midiinclosefunc"] = _csnd6.pycbdata_midiinclosefunc_set
    __swig_getmethods__["midiinclosefunc"] = _csnd6.pycbdata_midiinclosefunc_get
    if _newclass:
        midiinclosefunc = _swig_property(_csnd6.pycbdata_midiinclosefunc_get, _csnd6.pycbdata_midiinclosefunc_set)
    __swig_setmethods__["hostdata"] = _csnd6.pycbdata_hostdata_set
    __swig_getmethods__["hostdata"] = _csnd6.pycbdata_hostdata_get
    if _newclass:
        hostdata = _swig_property(_csnd6.pycbdata_hostdata_get, _csnd6.pycbdata_hostdata_set)
    __swig_setmethods__["messageBuffer"] = _csnd6.pycbdata_messageBuffer_set
    __swig_getmethods__["messageBuffer"] = _csnd6.pycbdata_messageBuffer_get
    if _newclass:
        messageBuffer = _swig_property(_csnd6.pycbdata_messageBuffer_get, _csnd6.pycbdata_messageBuffer_set)
    __swig_setmethods__["messageBufferIndex"] = _csnd6.pycbdata_messageBufferIndex_set
    __swig_getmethods__["messageBufferIndex"] = _csnd6.pycbdata_messageBufferIndex_get
    if _newclass:
        messageBufferIndex = _swig_property(_csnd6.pycbdata_messageBufferIndex_get, _csnd6.pycbdata_messageBufferIndex_set)

    def __init__(self):
        """__init__(pycbdata self) -> pycbdata"""
        this = _csnd6.new_pycbdata()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_pycbdata
    __del__ = lambda self: None
pycbdata_swigregister = _csnd6.pycbdata_swigregister
pycbdata_swigregister(pycbdata)

class Csound(_object):
    """Proxy of C++ Csound class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Csound, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Csound, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pydata"] = _csnd6.Csound_pydata_set
    __swig_getmethods__["pydata"] = _csnd6.Csound_pydata_get
    if _newclass:
        pydata = _swig_property(_csnd6.Csound_pydata_get, _csnd6.Csound_pydata_set)

    def GetCsound(self):
        """GetCsound(Csound self) -> CSOUND *"""
        return _csnd6.Csound_GetCsound(self)


    def SetCsound(self, csound_):
        """SetCsound(Csound self, CSOUND * csound_)"""
        return _csnd6.Csound_SetCsound(self, csound_)


    def InitializeCscore(self, insco, outsco):
        """InitializeCscore(Csound self, FILE * insco, FILE * outsco) -> int"""
        return _csnd6.Csound_InitializeCscore(self, insco, outsco)


    def GetVersion(self):
        """GetVersion(Csound self) -> int"""
        return _csnd6.Csound_GetVersion(self)


    def GetAPIVersion(self):
        """GetAPIVersion(Csound self) -> int"""
        return _csnd6.Csound_GetAPIVersion(self)


    def GetEnv(self, name):
        """GetEnv(Csound self, char const * name) -> char const *"""
        return _csnd6.Csound_GetEnv(self, name)


    def SetGlobalEnv(self, name, value):
        """SetGlobalEnv(Csound self, char const * name, char const * value) -> int"""
        return _csnd6.Csound_SetGlobalEnv(self, name, value)


    def SetOption(self, option):
        """SetOption(Csound self, char const * option) -> int"""
        return _csnd6.Csound_SetOption(self, option)


    def SetParams(self, p):
        """SetParams(Csound self, CSOUND_PARAMS p)"""
        return _csnd6.Csound_SetParams(self, p)


    def GetParams(self, p):
        """GetParams(Csound self, CSOUND_PARAMS p)"""
        return _csnd6.Csound_GetParams(self, p)


    def SetOutput(self, name, type, format):
        """SetOutput(Csound self, char const * name, char const * type, char const * format)"""
        return _csnd6.Csound_SetOutput(self, name, type, format)


    def SetInput(self, name):
        """SetInput(Csound self, char const * name)"""
        return _csnd6.Csound_SetInput(self, name)


    def SetMIDIInput(self, name):
        """SetMIDIInput(Csound self, char const * name)"""
        return _csnd6.Csound_SetMIDIInput(self, name)


    def SetMIDIFileInput(self, name):
        """SetMIDIFileInput(Csound self, char const * name)"""
        return _csnd6.Csound_SetMIDIFileInput(self, name)


    def SetMIDIOutput(self, name):
        """SetMIDIOutput(Csound self, char const * name)"""
        return _csnd6.Csound_SetMIDIOutput(self, name)


    def SetMIDIFileOutput(self, name):
        """SetMIDIFileOutput(Csound self, char const * name)"""
        return _csnd6.Csound_SetMIDIFileOutput(self, name)


    def ParseOrc(self, str):
        """ParseOrc(Csound self, char const * str) -> TREE"""
        return _csnd6.Csound_ParseOrc(self, str)


    def CompileTree(self, root):
        """CompileTree(Csound self, TREE root) -> int"""
        return _csnd6.Csound_CompileTree(self, root)


    def DeleteTree(self, root):
        """DeleteTree(Csound self, TREE root)"""
        return _csnd6.Csound_DeleteTree(self, root)


    def CompileOrc(self, str):
        """CompileOrc(Csound self, char const * str) -> int"""
        return _csnd6.Csound_CompileOrc(self, str)


    def EvalCode(self, str):
        """EvalCode(Csound self, char const * str) -> double"""
        return _csnd6.Csound_EvalCode(self, str)


    def ReadScore(self, str):
        """ReadScore(Csound self, char const * str) -> int"""
        return _csnd6.Csound_ReadScore(self, str)


    def CompileArgs(self, argc, argv):
        """CompileArgs(Csound self, int argc, char const ** argv) -> int"""
        return _csnd6.Csound_CompileArgs(self, argc, argv)


    def Compile(self, *args):
        """
        Compile(Csound self, int argc, char const ** argv) -> int
        Compile(Csound self, char const * csdName) -> int
        Compile(Csound self, char const * orcName, char const * scoName) -> int
        Compile(Csound self, char const * arg1, char const * arg2, char const * arg3) -> int
        Compile(Csound self, char const * arg1, char const * arg2, char const * arg3, char const * arg4) -> int
        Compile(Csound self, char const * arg1, char const * arg2, char const * arg3, char const * arg4, char const * arg5) -> int
        """
        return _csnd6.Csound_Compile(self, *args)


    def CompileCsd(self, csd):
        """CompileCsd(Csound self, char const * csd) -> int"""
        return _csnd6.Csound_CompileCsd(self, csd)


    def CompileCsdText(self, csd_text):
        """CompileCsdText(Csound self, char const * csd_text) -> int"""
        return _csnd6.Csound_CompileCsdText(self, csd_text)


    def Start(self):
        """Start(Csound self) -> int"""
        return _csnd6.Csound_Start(self)


    def Perform(self, *args):
        """
        Perform(Csound self) -> int
        Perform(Csound self, int argc, char const ** argv) -> int
        Perform(Csound self, char const * csdName) -> int
        Perform(Csound self, char const * orcName, char const * scoName) -> int
        Perform(Csound self, char const * arg1, char const * arg2, char const * arg3) -> int
        Perform(Csound self, char const * arg1, char const * arg2, char const * arg3, char const * arg4) -> int
        Perform(Csound self, char const * arg1, char const * arg2, char const * arg3, char const * arg4, char const * arg5) -> int
        """
        return _csnd6.Csound_Perform(self, *args)


    def PerformKsmps(self):
        """PerformKsmps(Csound self) -> int"""
        return _csnd6.Csound_PerformKsmps(self)


    def PerformBuffer(self):
        """PerformBuffer(Csound self) -> int"""
        return _csnd6.Csound_PerformBuffer(self)


    def Stop(self):
        """Stop(Csound self)"""
        return _csnd6.Csound_Stop(self)


    def Cleanup(self):
        """Cleanup(Csound self) -> int"""
        return _csnd6.Csound_Cleanup(self)


    def Reset(self):
        """Reset(Csound self)"""
        return _csnd6.Csound_Reset(self)


    def GetSr(self):
        """GetSr(Csound self) -> double"""
        return _csnd6.Csound_GetSr(self)


    def GetKr(self):
        """GetKr(Csound self) -> double"""
        return _csnd6.Csound_GetKr(self)


    def GetKsmps(self):
        """GetKsmps(Csound self) -> int"""
        return _csnd6.Csound_GetKsmps(self)


    def GetNchnls(self):
        """GetNchnls(Csound self) -> int"""
        return _csnd6.Csound_GetNchnls(self)


    def GetNchnlsInput(self):
        """GetNchnlsInput(Csound self) -> int"""
        return _csnd6.Csound_GetNchnlsInput(self)


    def Get0dBFS(self):
        """Get0dBFS(Csound self) -> double"""
        return _csnd6.Csound_Get0dBFS(self)


    def GetInputBufferSize(self):
        """GetInputBufferSize(Csound self) -> long"""
        return _csnd6.Csound_GetInputBufferSize(self)


    def GetOutputBufferSize(self):
        """GetOutputBufferSize(Csound self) -> long"""
        return _csnd6.Csound_GetOutputBufferSize(self)


    def GetInputBuffer(self):
        """GetInputBuffer(Csound self) -> double *"""
        return _csnd6.Csound_GetInputBuffer(self)


    def GetOutputBuffer(self):
        """GetOutputBuffer(Csound self) -> double *"""
        return _csnd6.Csound_GetOutputBuffer(self)


    def GetSpin(self):
        """GetSpin(Csound self) -> double *"""
        return _csnd6.Csound_GetSpin(self)


    def GetSpout(self):
        """GetSpout(Csound self) -> double *"""
        return _csnd6.Csound_GetSpout(self)


    def GetOutputName(self):
        """GetOutputName(Csound self) -> char const *"""
        return _csnd6.Csound_GetOutputName(self)


    def GetCurrentTimeSamples(self):
        """GetCurrentTimeSamples(Csound self) -> long"""
        return _csnd6.Csound_GetCurrentTimeSamples(self)


    def SetHostImplementedAudioIO(self, state, bufSize):
        """SetHostImplementedAudioIO(Csound self, int state, int bufSize)"""
        return _csnd6.Csound_SetHostImplementedAudioIO(self, state, bufSize)


    def SetHostImplementedMIDIIO(self, state):
        """SetHostImplementedMIDIIO(Csound self, int state)"""
        return _csnd6.Csound_SetHostImplementedMIDIIO(self, state)


    def GetScoreTime(self):
        """GetScoreTime(Csound self) -> double"""
        return _csnd6.Csound_GetScoreTime(self)


    def IsScorePending(self):
        """IsScorePending(Csound self) -> int"""
        return _csnd6.Csound_IsScorePending(self)


    def SetScorePending(self, pending):
        """SetScorePending(Csound self, int pending)"""
        return _csnd6.Csound_SetScorePending(self, pending)


    def GetScoreOffsetSeconds(self):
        """GetScoreOffsetSeconds(Csound self) -> double"""
        return _csnd6.Csound_GetScoreOffsetSeconds(self)


    def SetScoreOffsetSeconds(self, time):
        """SetScoreOffsetSeconds(Csound self, double time)"""
        return _csnd6.Csound_SetScoreOffsetSeconds(self, time)


    def RewindScore(self):
        """RewindScore(Csound self)"""
        return _csnd6.Csound_RewindScore(self)


    def ScoreSort(self, inFile, outFile):
        """ScoreSort(Csound self, FILE * inFile, FILE * outFile) -> int"""
        return _csnd6.Csound_ScoreSort(self, inFile, outFile)


    def ScoreExtract(self, inFile, outFile, extractFile):
        """ScoreExtract(Csound self, FILE * inFile, FILE * outFile, FILE * extractFile) -> int"""
        return _csnd6.Csound_ScoreExtract(self, inFile, outFile, extractFile)


    def Message(self, format):
        """Message(Csound self, char const * format)"""
        return _csnd6.Csound_Message(self, format)


    def MessageS(self, attr, format):
        """MessageS(Csound self, int attr, char const * format)"""
        return _csnd6.Csound_MessageS(self, attr, format)


    def GetMessageLevel(self):
        """GetMessageLevel(Csound self) -> int"""
        return _csnd6.Csound_GetMessageLevel(self)


    def SetMessageLevel(self, messageLevel):
        """SetMessageLevel(Csound self, int messageLevel)"""
        return _csnd6.Csound_SetMessageLevel(self, messageLevel)


    def InputMessage(self, message):
        """InputMessage(Csound self, char const * message)"""
        return _csnd6.Csound_InputMessage(self, message)


    def KeyPressed(self, c):
        """KeyPressed(Csound self, char c)"""
        return _csnd6.Csound_KeyPressed(self, c)


    def ScoreEvent(self, type, pFields, numFields):
        """ScoreEvent(Csound self, char type, double const * pFields, long numFields) -> int"""
        return _csnd6.Csound_ScoreEvent(self, type, pFields, numFields)


    def ScoreEventAbsolute(self, type, pFields, numFields, time_ofs):
        """ScoreEventAbsolute(Csound self, char type, double const * pFields, long numFields, double time_ofs) -> int"""
        return _csnd6.Csound_ScoreEventAbsolute(self, type, pFields, numFields, time_ofs)


    def NewOpcodeList(self, opcodelist):
        """NewOpcodeList(Csound self, opcodeListEntry *& opcodelist) -> int"""
        return _csnd6.Csound_NewOpcodeList(self, opcodelist)


    def DisposeOpcodeList(self, opcodelist):
        """DisposeOpcodeList(Csound self, opcodeListEntry opcodelist)"""
        return _csnd6.Csound_DisposeOpcodeList(self, opcodelist)


    def AppendOpcode(self, opname, dsblksiz, flags, thread, outypes, intypes, iopadr, kopadr, aopadr):
        """AppendOpcode(Csound self, char const * opname, int dsblksiz, int flags, int thread, char const * outypes, char const * intypes, int (*)(CSOUND *,void *) iopadr, int (*)(CSOUND *,void *) kopadr, int (*)(CSOUND *,void *) aopadr) -> int"""
        return _csnd6.Csound_AppendOpcode(self, opname, dsblksiz, flags, thread, outypes, intypes, iopadr, kopadr, aopadr)


    def GetDebug(self):
        """GetDebug(Csound self) -> int"""
        return _csnd6.Csound_GetDebug(self)


    def SetDebug(self, debug):
        """SetDebug(Csound self, int debug)"""
        return _csnd6.Csound_SetDebug(self, debug)


    def TableLength(self, table):
        """TableLength(Csound self, int table) -> int"""
        return _csnd6.Csound_TableLength(self, table)


    def TableGet(self, table, index):
        """TableGet(Csound self, int table, int index) -> double"""
        return _csnd6.Csound_TableGet(self, table, index)


    def TableSet(self, table, index, value):
        """TableSet(Csound self, int table, int index, double value)"""
        return _csnd6.Csound_TableSet(self, table, index, value)


    def GetTable(self, tablePtr, tableNum):
        """GetTable(Csound self, double *& tablePtr, int tableNum) -> int"""
        return _csnd6.Csound_GetTable(self, tablePtr, tableNum)


    def TableCopyOut(self, table, dest):
        """TableCopyOut(Csound self, int table, double * dest)"""
        return _csnd6.Csound_TableCopyOut(self, table, dest)


    def TableCopyIn(self, table, src):
        """TableCopyIn(Csound self, int table, double * src)"""
        return _csnd6.Csound_TableCopyIn(self, table, src)


    def CreateGlobalVariable(self, name, nbytes):
        """CreateGlobalVariable(Csound self, char const * name, size_t nbytes) -> int"""
        return _csnd6.Csound_CreateGlobalVariable(self, name, nbytes)


    def QueryGlobalVariable(self, name):
        """QueryGlobalVariable(Csound self, char const * name) -> void *"""
        return _csnd6.Csound_QueryGlobalVariable(self, name)


    def QueryGlobalVariableNoCheck(self, name):
        """QueryGlobalVariableNoCheck(Csound self, char const * name) -> void *"""
        return _csnd6.Csound_QueryGlobalVariableNoCheck(self, name)


    def DestroyGlobalVariable(self, name):
        """DestroyGlobalVariable(Csound self, char const * name) -> int"""
        return _csnd6.Csound_DestroyGlobalVariable(self, name)


    def GetRtRecordUserData(self):
        """GetRtRecordUserData(Csound self) -> void **"""
        return _csnd6.Csound_GetRtRecordUserData(self)


    def GetRtPlayUserData(self):
        """GetRtPlayUserData(Csound self) -> void **"""
        return _csnd6.Csound_GetRtPlayUserData(self)


    def RunUtility(self, name, argc, argv):
        """RunUtility(Csound self, char const * name, int argc, char ** argv) -> int"""
        return _csnd6.Csound_RunUtility(self, name, argc, argv)


    def ListUtilities(self):
        """ListUtilities(Csound self) -> char **"""
        return _csnd6.Csound_ListUtilities(self)


    def DeleteUtilityList(self, lst):
        """DeleteUtilityList(Csound self, char ** lst)"""
        return _csnd6.Csound_DeleteUtilityList(self, lst)


    def GetUtilityDescription(self, utilName):
        """GetUtilityDescription(Csound self, char const * utilName) -> char const *"""
        return _csnd6.Csound_GetUtilityDescription(self, utilName)


    def GetChannelPtr(self, p, name, type):
        """GetChannelPtr(Csound self, double *& p, char const * name, int type) -> int"""
        return _csnd6.Csound_GetChannelPtr(self, p, name, type)


    def ListChannels(self, lst):
        """ListChannels(Csound self, controlChannelInfo_t *& lst) -> int"""
        return _csnd6.Csound_ListChannels(self, lst)


    def DeleteChannelList(self, lst):
        """DeleteChannelList(Csound self, controlChannelInfo_t lst)"""
        return _csnd6.Csound_DeleteChannelList(self, lst)


    def SetControlChannelHints(self, name, hints):
        """SetControlChannelHints(Csound self, char const * name, controlChannelHints_t hints) -> int"""
        return _csnd6.Csound_SetControlChannelHints(self, name, hints)


    def GetControlChannelHints(self, name, hints):
        """GetControlChannelHints(Csound self, char const * name, controlChannelHints_t hints) -> int"""
        return _csnd6.Csound_GetControlChannelHints(self, name, hints)


    def SetControlChannel(self, name, value):
        """SetControlChannel(Csound self, char const * name, double value)"""
        return _csnd6.Csound_SetControlChannel(self, name, value)


    def SetStringChannel(self, name, string):
        """SetStringChannel(Csound self, char const * name, char * string)"""
        return _csnd6.Csound_SetStringChannel(self, name, string)


    def SetChannel(self, *args):
        """
        SetChannel(Csound self, char const * name, double value)
        SetChannel(Csound self, char const * name, char * string)
        SetChannel(Csound self, char const * name, double * samples)
        """
        return _csnd6.Csound_SetChannel(self, *args)


    def GetChannel(self, name, err=None):
        """
        GetChannel(Csound self, char const * name, int * err=None) -> double
        GetChannel(Csound self, char const * name) -> double
        """
        return _csnd6.Csound_GetChannel(self, name, err)


    def GetControlChannel(self, name, err=None):
        """
        GetControlChannel(Csound self, char const * name, int * err=None) -> double
        GetControlChannel(Csound self, char const * name) -> double
        """
        return _csnd6.Csound_GetControlChannel(self, name, err)


    def GetStringChannel(self, name, string):
        """GetStringChannel(Csound self, char const * name, char * string)"""
        return _csnd6.Csound_GetStringChannel(self, name, string)


    def GetAudioChannel(self, name, samples):
        """GetAudioChannel(Csound self, char const * name, double * samples)"""
        return _csnd6.Csound_GetAudioChannel(self, name, samples)


    def PvsinSet(self, value, name):
        """PvsinSet(Csound self, PVSDATEXT value, char const * name) -> int"""
        return _csnd6.Csound_PvsinSet(self, value, name)


    def PvsoutGet(self, value, name):
        """PvsoutGet(Csound self, PVSDATEXT value, char const * name) -> int"""
        return _csnd6.Csound_PvsoutGet(self, value, name)


    def __init__(self, *args):
        """
        __init__(Csound self) -> Csound
        __init__(Csound self, CSOUND * csound_) -> Csound
        __init__(Csound self, void * hostData) -> Csound
        """
        this = _csnd6.new_Csound(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_Csound
    __del__ = lambda self: None

    def CreateMessageBuffer(self, toStdOut):
        """CreateMessageBuffer(Csound self, int toStdOut)"""
        return _csnd6.Csound_CreateMessageBuffer(self, toStdOut)


    def GetFirstMessage(self):
        """GetFirstMessage(Csound self) -> char const *"""
        return _csnd6.Csound_GetFirstMessage(self)


    def GetFirstMessageAttr(self):
        """GetFirstMessageAttr(Csound self) -> int"""
        return _csnd6.Csound_GetFirstMessageAttr(self)


    def PopFirstMessage(self):
        """PopFirstMessage(Csound self)"""
        return _csnd6.Csound_PopFirstMessage(self)


    def GetMessageCnt(self):
        """GetMessageCnt(Csound self) -> int"""
        return _csnd6.Csound_GetMessageCnt(self)


    def DestroyMessageBuffer(self):
        """DestroyMessageBuffer(Csound self)"""
        return _csnd6.Csound_DestroyMessageBuffer(self)


    def AddSpinSample(self, frame, channel, sample):
        """AddSpinSample(Csound self, int frame, int channel, double sample)"""
        return _csnd6.Csound_AddSpinSample(self, frame, channel, sample)


    def GetSpoutSample(self, frame, channel):
        """GetSpoutSample(Csound self, int frame, int channel) -> double"""
        return _csnd6.Csound_GetSpoutSample(self, frame, channel)


    def GetInputName(self):
        """GetInputName(Csound self) -> char const *"""
        return _csnd6.Csound_GetInputName(self)


    def SetMessageCallback(self, pyfunc):
        """SetMessageCallback(Csound self, PyObject * pyfunc)"""
        return _csnd6.Csound_SetMessageCallback(self, pyfunc)


    def SetInputChannelCallback(self, pyfunc):
        """SetInputChannelCallback(Csound self, PyObject * pyfunc)"""
        return _csnd6.Csound_SetInputChannelCallback(self, pyfunc)


    def SetOutputChannelCallback(self, pyfunc):
        """SetOutputChannelCallback(Csound self, PyObject * pyfunc)"""
        return _csnd6.Csound_SetOutputChannelCallback(self, pyfunc)


    def SetExternalMidiInOpenCallback(self, *args):
        """
        SetExternalMidiInOpenCallback(Csound self, int (*)(CSOUND *,void **,char const *) func)
        SetExternalMidiInOpenCallback(Csound self, PyObject * pyfunc)
        """
        return _csnd6.Csound_SetExternalMidiInOpenCallback(self, *args)


    def SetExternalMidiInCloseCallback(self, pyfunc):
        """SetExternalMidiInCloseCallback(Csound self, PyObject * pyfunc)"""
        return _csnd6.Csound_SetExternalMidiInCloseCallback(self, pyfunc)


    def SetExternalMidiReadCallback(self, pyfunc):
        """SetExternalMidiReadCallback(Csound self, PyObject * pyfunc)"""
        return _csnd6.Csound_SetExternalMidiReadCallback(self, pyfunc)

Csound_swigregister = _csnd6.Csound_swigregister
Csound_swigregister(Csound)

class CsoundThreadLock(_object):
    """Proxy of C++ CsoundThreadLock class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundThreadLock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundThreadLock, name)
    __repr__ = _swig_repr

    def Lock(self, *args):
        """
        Lock(CsoundThreadLock self, size_t milliseconds) -> int
        Lock(CsoundThreadLock self)
        """
        return _csnd6.CsoundThreadLock_Lock(self, *args)


    def TryLock(self):
        """TryLock(CsoundThreadLock self) -> int"""
        return _csnd6.CsoundThreadLock_TryLock(self)


    def Unlock(self):
        """Unlock(CsoundThreadLock self)"""
        return _csnd6.CsoundThreadLock_Unlock(self)


    def __init__(self, *args):
        """
        __init__(CsoundThreadLock self) -> CsoundThreadLock
        __init__(CsoundThreadLock self, int locked) -> CsoundThreadLock
        """
        this = _csnd6.new_CsoundThreadLock(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundThreadLock
    __del__ = lambda self: None
CsoundThreadLock_swigregister = _csnd6.CsoundThreadLock_swigregister
CsoundThreadLock_swigregister(CsoundThreadLock)

class CsoundMutex(_object):
    """Proxy of C++ CsoundMutex class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMutex, name)
    __repr__ = _swig_repr

    def Lock(self):
        """Lock(CsoundMutex self)"""
        return _csnd6.CsoundMutex_Lock(self)


    def TryLock(self):
        """TryLock(CsoundMutex self) -> int"""
        return _csnd6.CsoundMutex_TryLock(self)


    def Unlock(self):
        """Unlock(CsoundMutex self)"""
        return _csnd6.CsoundMutex_Unlock(self)


    def __init__(self, *args):
        """
        __init__(CsoundMutex self) -> CsoundMutex
        __init__(CsoundMutex self, int isRecursive) -> CsoundMutex
        """
        this = _csnd6.new_CsoundMutex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundMutex
    __del__ = lambda self: None
CsoundMutex_swigregister = _csnd6.CsoundMutex_swigregister
CsoundMutex_swigregister(CsoundMutex)

class CsoundRandMT(_object):
    """Proxy of C++ CsoundRandMT class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundRandMT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundRandMT, name)
    __repr__ = _swig_repr

    def Random(self):
        """Random(CsoundRandMT self) -> uint32_t"""
        return _csnd6.CsoundRandMT_Random(self)


    def Seed(self, *args):
        """
        Seed(CsoundRandMT self, uint32_t seedVal)
        Seed(CsoundRandMT self, uint32_t const * initKey, int keyLength)
        """
        return _csnd6.CsoundRandMT_Seed(self, *args)


    def __init__(self, *args):
        """
        __init__(CsoundRandMT self) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t seedVal) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t const * initKey, int keyLength) -> CsoundRandMT
        """
        this = _csnd6.new_CsoundRandMT(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundRandMT
    __del__ = lambda self: None
CsoundRandMT_swigregister = _csnd6.CsoundRandMT_swigregister
CsoundRandMT_swigregister(CsoundRandMT)

class CsoundTimer(_object):
    """Proxy of C++ CsoundTimer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundTimer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundTimer, name)
    __repr__ = _swig_repr

    def GetRealTime(self):
        """GetRealTime(CsoundTimer self) -> double"""
        return _csnd6.CsoundTimer_GetRealTime(self)


    def GetCPUTime(self):
        """GetCPUTime(CsoundTimer self) -> double"""
        return _csnd6.CsoundTimer_GetCPUTime(self)


    def Reset(self):
        """Reset(CsoundTimer self)"""
        return _csnd6.CsoundTimer_Reset(self)


    def __init__(self):
        """__init__(CsoundTimer self) -> CsoundTimer"""
        this = _csnd6.new_CsoundTimer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundTimer
    __del__ = lambda self: None
CsoundTimer_swigregister = _csnd6.CsoundTimer_swigregister
CsoundTimer_swigregister(CsoundTimer)

class CsoundOpcodeList(_object):
    """Proxy of C++ CsoundOpcodeList class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundOpcodeList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundOpcodeList, name)
    __repr__ = _swig_repr

    def Count(self):
        """Count(CsoundOpcodeList self) -> int"""
        return _csnd6.CsoundOpcodeList_Count(self)


    def Name(self, ndx):
        """Name(CsoundOpcodeList self, int ndx) -> char const *"""
        return _csnd6.CsoundOpcodeList_Name(self, ndx)


    def OutTypes(self, ndx):
        """OutTypes(CsoundOpcodeList self, int ndx) -> char const *"""
        return _csnd6.CsoundOpcodeList_OutTypes(self, ndx)


    def InTypes(self, ndx):
        """InTypes(CsoundOpcodeList self, int ndx) -> char const *"""
        return _csnd6.CsoundOpcodeList_InTypes(self, ndx)


    def Clear(self):
        """Clear(CsoundOpcodeList self)"""
        return _csnd6.CsoundOpcodeList_Clear(self)


    def __init__(self, *args):
        """
        __init__(CsoundOpcodeList self, CSOUND * csound) -> CsoundOpcodeList
        __init__(CsoundOpcodeList self, Csound csound) -> CsoundOpcodeList
        """
        this = _csnd6.new_CsoundOpcodeList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundOpcodeList
    __del__ = lambda self: None
CsoundOpcodeList_swigregister = _csnd6.CsoundOpcodeList_swigregister
CsoundOpcodeList_swigregister(CsoundOpcodeList)

class CsoundChannelList(_object):
    """Proxy of C++ CsoundChannelList class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundChannelList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundChannelList, name)
    __repr__ = _swig_repr

    def Count(self):
        """Count(CsoundChannelList self) -> int"""
        return _csnd6.CsoundChannelList_Count(self)


    def Name(self, ndx):
        """Name(CsoundChannelList self, int ndx) -> char const *"""
        return _csnd6.CsoundChannelList_Name(self, ndx)


    def Type(self, ndx):
        """Type(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_Type(self, ndx)


    def IsControlChannel(self, ndx):
        """IsControlChannel(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_IsControlChannel(self, ndx)


    def IsAudioChannel(self, ndx):
        """IsAudioChannel(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_IsAudioChannel(self, ndx)


    def IsStringChannel(self, ndx):
        """IsStringChannel(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_IsStringChannel(self, ndx)


    def IsInputChannel(self, ndx):
        """IsInputChannel(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_IsInputChannel(self, ndx)


    def IsOutputChannel(self, ndx):
        """IsOutputChannel(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_IsOutputChannel(self, ndx)


    def SubType(self, ndx):
        """SubType(CsoundChannelList self, int ndx) -> int"""
        return _csnd6.CsoundChannelList_SubType(self, ndx)


    def DefaultValue(self, ndx):
        """DefaultValue(CsoundChannelList self, int ndx) -> double"""
        return _csnd6.CsoundChannelList_DefaultValue(self, ndx)


    def MinValue(self, ndx):
        """MinValue(CsoundChannelList self, int ndx) -> double"""
        return _csnd6.CsoundChannelList_MinValue(self, ndx)


    def MaxValue(self, ndx):
        """MaxValue(CsoundChannelList self, int ndx) -> double"""
        return _csnd6.CsoundChannelList_MaxValue(self, ndx)


    def Clear(self):
        """Clear(CsoundChannelList self)"""
        return _csnd6.CsoundChannelList_Clear(self)


    def __init__(self, *args):
        """
        __init__(CsoundChannelList self, CSOUND * csound) -> CsoundChannelList
        __init__(CsoundChannelList self, Csound csound) -> CsoundChannelList
        """
        this = _csnd6.new_CsoundChannelList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundChannelList
    __del__ = lambda self: None
CsoundChannelList_swigregister = _csnd6.CsoundChannelList_swigregister
CsoundChannelList_swigregister(CsoundChannelList)

class CsoundUtilityList(_object):
    """Proxy of C++ CsoundUtilityList class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundUtilityList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundUtilityList, name)
    __repr__ = _swig_repr

    def Count(self):
        """Count(CsoundUtilityList self) -> int"""
        return _csnd6.CsoundUtilityList_Count(self)


    def Name(self, ndx):
        """Name(CsoundUtilityList self, int ndx) -> char const *"""
        return _csnd6.CsoundUtilityList_Name(self, ndx)


    def Clear(self):
        """Clear(CsoundUtilityList self)"""
        return _csnd6.CsoundUtilityList_Clear(self)


    def __init__(self, *args):
        """
        __init__(CsoundUtilityList self, CSOUND * csound) -> CsoundUtilityList
        __init__(CsoundUtilityList self, Csound csound) -> CsoundUtilityList
        """
        this = _csnd6.new_CsoundUtilityList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundUtilityList
    __del__ = lambda self: None
CsoundUtilityList_swigregister = _csnd6.CsoundUtilityList_swigregister
CsoundUtilityList_swigregister(CsoundUtilityList)

class CsoundMYFLTArray(_object):
    """Proxy of C++ CsoundMYFLTArray class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMYFLTArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMYFLTArray, name)
    __repr__ = _swig_repr

    def GetPtr(self, *args):
        """
        GetPtr(CsoundMYFLTArray self) -> double
        GetPtr(CsoundMYFLTArray self, int ndx) -> double *
        """
        return _csnd6.CsoundMYFLTArray_GetPtr(self, *args)


    def SetPtr(self, ptr):
        """SetPtr(CsoundMYFLTArray self, double * ptr)"""
        return _csnd6.CsoundMYFLTArray_SetPtr(self, ptr)


    def SetValue(self, ndx, value):
        """SetValue(CsoundMYFLTArray self, int ndx, double value)"""
        return _csnd6.CsoundMYFLTArray_SetValue(self, ndx, value)


    def GetValue(self, ndx):
        """GetValue(CsoundMYFLTArray self, int ndx) -> double"""
        return _csnd6.CsoundMYFLTArray_GetValue(self, ndx)


    def SetValues(self, *args):
        """
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4, double v5)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4, double v5, double v6)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7, double v8)
        SetValues(CsoundMYFLTArray self, int ndx, double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7, double v8, double v9)
        SetValues(CsoundMYFLTArray self, int ndx, int n, double const * src)
        """
        return _csnd6.CsoundMYFLTArray_SetValues(self, *args)


    def GetValues(self, dst, ndx, n):
        """GetValues(CsoundMYFLTArray self, double * dst, int ndx, int n)"""
        return _csnd6.CsoundMYFLTArray_GetValues(self, dst, ndx, n)


    def SetStringValue(self, s, maxLen):
        """SetStringValue(CsoundMYFLTArray self, char const * s, int maxLen)"""
        return _csnd6.CsoundMYFLTArray_SetStringValue(self, s, maxLen)


    def GetStringValue(self):
        """GetStringValue(CsoundMYFLTArray self) -> char const *"""
        return _csnd6.CsoundMYFLTArray_GetStringValue(self)


    def Clear(self):
        """Clear(CsoundMYFLTArray self)"""
        return _csnd6.CsoundMYFLTArray_Clear(self)


    def __init__(self, *args):
        """
        __init__(CsoundMYFLTArray self) -> CsoundMYFLTArray
        __init__(CsoundMYFLTArray self, int n) -> CsoundMYFLTArray
        """
        this = _csnd6.new_CsoundMYFLTArray(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundMYFLTArray
    __del__ = lambda self: None
CsoundMYFLTArray_swigregister = _csnd6.CsoundMYFLTArray_swigregister
CsoundMYFLTArray_swigregister(CsoundMYFLTArray)

class CsoundArgVList(_object):
    """Proxy of C++ CsoundArgVList class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundArgVList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundArgVList, name)
    __repr__ = _swig_repr

    def argc(self):
        """argc(CsoundArgVList self) -> int"""
        return _csnd6.CsoundArgVList_argc(self)


    def argv(self, *args):
        """
        argv(CsoundArgVList self) -> char
        argv(CsoundArgVList self, int ndx) -> char const *
        """
        return _csnd6.CsoundArgVList_argv(self, *args)


    def Insert(self, ndx, s):
        """Insert(CsoundArgVList self, int ndx, char const * s)"""
        return _csnd6.CsoundArgVList_Insert(self, ndx, s)


    def Append(self, s):
        """Append(CsoundArgVList self, char const * s)"""
        return _csnd6.CsoundArgVList_Append(self, s)


    def Clear(self):
        """Clear(CsoundArgVList self)"""
        return _csnd6.CsoundArgVList_Clear(self)


    def __init__(self):
        """__init__(CsoundArgVList self) -> CsoundArgVList"""
        this = _csnd6.new_CsoundArgVList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundArgVList
    __del__ = lambda self: None
CsoundArgVList_swigregister = _csnd6.CsoundArgVList_swigregister
CsoundArgVList_swigregister(CsoundArgVList)

class CsoundCallbackWrapper(_object):
    """Proxy of C++ CsoundCallbackWrapper class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundCallbackWrapper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundCallbackWrapper, name)
    __repr__ = _swig_repr

    def MessageCallback(self, attr, msg):
        """MessageCallback(CsoundCallbackWrapper self, int attr, char * msg)"""
        return _csnd6.CsoundCallbackWrapper_MessageCallback(self, attr, msg)


    def InputValueCallback(self, chnName):
        """InputValueCallback(CsoundCallbackWrapper self, char const * chnName) -> double"""
        return _csnd6.CsoundCallbackWrapper_InputValueCallback(self, chnName)


    def OutputValueCallback(self, chnName, value):
        """OutputValueCallback(CsoundCallbackWrapper self, char const * chnName, double value)"""
        return _csnd6.CsoundCallbackWrapper_OutputValueCallback(self, chnName, value)


    def YieldCallback(self):
        """YieldCallback(CsoundCallbackWrapper self) -> int"""
        return _csnd6.CsoundCallbackWrapper_YieldCallback(self)


    def MidiInputCallback(self, p):
        """MidiInputCallback(CsoundCallbackWrapper self, CsoundMidiInputBuffer p)"""
        return _csnd6.CsoundCallbackWrapper_MidiInputCallback(self, p)


    def MidiOutputCallback(self, p):
        """MidiOutputCallback(CsoundCallbackWrapper self, CsoundMidiOutputBuffer p)"""
        return _csnd6.CsoundCallbackWrapper_MidiOutputCallback(self, p)


    def SetMessageCallback(self):
        """SetMessageCallback(CsoundCallbackWrapper self)"""
        return _csnd6.CsoundCallbackWrapper_SetMessageCallback(self)


    def SetYieldCallback(self):
        """SetYieldCallback(CsoundCallbackWrapper self)"""
        return _csnd6.CsoundCallbackWrapper_SetYieldCallback(self)


    def SetMidiInputCallback(self, argv):
        """SetMidiInputCallback(CsoundCallbackWrapper self, CsoundArgVList argv)"""
        return _csnd6.CsoundCallbackWrapper_SetMidiInputCallback(self, argv)


    def SetMidiOutputCallback(self, argv):
        """SetMidiOutputCallback(CsoundCallbackWrapper self, CsoundArgVList argv)"""
        return _csnd6.CsoundCallbackWrapper_SetMidiOutputCallback(self, argv)


    def GetCsound(self):
        """GetCsound(CsoundCallbackWrapper self) -> CSOUND *"""
        return _csnd6.CsoundCallbackWrapper_GetCsound(self)


    def CharPtrToString(s):
        """CharPtrToString(char const * s) -> char const *"""
        return _csnd6.CsoundCallbackWrapper_CharPtrToString(s)

    CharPtrToString = staticmethod(CharPtrToString)

    def __init__(self, *args):
        """
        __init__(CsoundCallbackWrapper self, Csound csound) -> CsoundCallbackWrapper
        __init__(CsoundCallbackWrapper self, CSOUND * csound) -> CsoundCallbackWrapper
        """
        if self.__class__ == CsoundCallbackWrapper:
            _self = None
        else:
            _self = self
        this = _csnd6.new_CsoundCallbackWrapper(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundCallbackWrapper
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _csnd6.disown_CsoundCallbackWrapper(self)
        return weakref_proxy(self)
CsoundCallbackWrapper_swigregister = _csnd6.CsoundCallbackWrapper_swigregister
CsoundCallbackWrapper_swigregister(CsoundCallbackWrapper)

def CsoundCallbackWrapper_CharPtrToString(s):
    """CsoundCallbackWrapper_CharPtrToString(char const * s) -> char const *"""
    return _csnd6.CsoundCallbackWrapper_CharPtrToString(s)

class CsoundMidiInputBuffer(_object):
    """Proxy of C++ CsoundMidiInputBuffer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiInputBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiInputBuffer, name)
    __repr__ = _swig_repr

    def __init__(self, buf, bufSize):
        """__init__(CsoundMidiInputBuffer self, unsigned char * buf, int bufSize) -> CsoundMidiInputBuffer"""
        this = _csnd6.new_CsoundMidiInputBuffer(buf, bufSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundMidiInputBuffer
    __del__ = lambda self: None

    def SendMidiMessage(self, *args):
        """
        SendMidiMessage(CsoundMidiInputBuffer self, int msg)
        SendMidiMessage(CsoundMidiInputBuffer self, int status, int channel, int data1, int data2)
        """
        return _csnd6.CsoundMidiInputBuffer_SendMidiMessage(self, *args)


    def SendNoteOn(self, channel, key, velocity):
        """SendNoteOn(CsoundMidiInputBuffer self, int channel, int key, int velocity)"""
        return _csnd6.CsoundMidiInputBuffer_SendNoteOn(self, channel, key, velocity)


    def SendNoteOff(self, *args):
        """
        SendNoteOff(CsoundMidiInputBuffer self, int channel, int key, int velocity)
        SendNoteOff(CsoundMidiInputBuffer self, int channel, int key)
        """
        return _csnd6.CsoundMidiInputBuffer_SendNoteOff(self, *args)


    def SendPolyphonicPressure(self, channel, key, value):
        """SendPolyphonicPressure(CsoundMidiInputBuffer self, int channel, int key, int value)"""
        return _csnd6.CsoundMidiInputBuffer_SendPolyphonicPressure(self, channel, key, value)


    def SendControlChange(self, channel, ctl, value):
        """SendControlChange(CsoundMidiInputBuffer self, int channel, int ctl, int value)"""
        return _csnd6.CsoundMidiInputBuffer_SendControlChange(self, channel, ctl, value)


    def SendProgramChange(self, channel, pgm):
        """SendProgramChange(CsoundMidiInputBuffer self, int channel, int pgm)"""
        return _csnd6.CsoundMidiInputBuffer_SendProgramChange(self, channel, pgm)


    def SendChannelPressure(self, channel, value):
        """SendChannelPressure(CsoundMidiInputBuffer self, int channel, int value)"""
        return _csnd6.CsoundMidiInputBuffer_SendChannelPressure(self, channel, value)


    def SendPitchBend(self, channel, value):
        """SendPitchBend(CsoundMidiInputBuffer self, int channel, int value)"""
        return _csnd6.CsoundMidiInputBuffer_SendPitchBend(self, channel, value)

CsoundMidiInputBuffer_swigregister = _csnd6.CsoundMidiInputBuffer_swigregister
CsoundMidiInputBuffer_swigregister(CsoundMidiInputBuffer)

class CsoundMidiInputStream(CsoundMidiInputBuffer):
    """Proxy of C++ CsoundMidiInputStream class."""

    __swig_setmethods__ = {}
    for _s in [CsoundMidiInputBuffer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiInputStream, name, value)
    __swig_getmethods__ = {}
    for _s in [CsoundMidiInputBuffer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiInputStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CsoundMidiInputStream self, CSOUND * csound) -> CsoundMidiInputStream
        __init__(CsoundMidiInputStream self, Csound csound) -> CsoundMidiInputStream
        """
        this = _csnd6.new_CsoundMidiInputStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def EnableMidiInput(self, argv):
        """EnableMidiInput(CsoundMidiInputStream self, CsoundArgVList argv)"""
        return _csnd6.CsoundMidiInputStream_EnableMidiInput(self, argv)

    __swig_destroy__ = _csnd6.delete_CsoundMidiInputStream
    __del__ = lambda self: None
CsoundMidiInputStream_swigregister = _csnd6.CsoundMidiInputStream_swigregister
CsoundMidiInputStream_swigregister(CsoundMidiInputStream)

class CsoundMidiOutputBuffer(_object):
    """Proxy of C++ CsoundMidiOutputBuffer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiOutputBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiOutputBuffer, name)
    __repr__ = _swig_repr

    def __init__(self, buf, bufSize):
        """__init__(CsoundMidiOutputBuffer self, unsigned char * buf, int bufSize) -> CsoundMidiOutputBuffer"""
        this = _csnd6.new_CsoundMidiOutputBuffer(buf, bufSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundMidiOutputBuffer
    __del__ = lambda self: None

    def PopMessage(self):
        """PopMessage(CsoundMidiOutputBuffer self) -> int"""
        return _csnd6.CsoundMidiOutputBuffer_PopMessage(self)


    def GetStatus(self):
        """GetStatus(CsoundMidiOutputBuffer self) -> int"""
        return _csnd6.CsoundMidiOutputBuffer_GetStatus(self)


    def GetChannel(self):
        """GetChannel(CsoundMidiOutputBuffer self) -> int"""
        return _csnd6.CsoundMidiOutputBuffer_GetChannel(self)


    def GetData1(self):
        """GetData1(CsoundMidiOutputBuffer self) -> int"""
        return _csnd6.CsoundMidiOutputBuffer_GetData1(self)


    def GetData2(self):
        """GetData2(CsoundMidiOutputBuffer self) -> int"""
        return _csnd6.CsoundMidiOutputBuffer_GetData2(self)

CsoundMidiOutputBuffer_swigregister = _csnd6.CsoundMidiOutputBuffer_swigregister
CsoundMidiOutputBuffer_swigregister(CsoundMidiOutputBuffer)

class CsoundMidiOutputStream(CsoundMidiOutputBuffer):
    """Proxy of C++ CsoundMidiOutputStream class."""

    __swig_setmethods__ = {}
    for _s in [CsoundMidiOutputBuffer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundMidiOutputStream, name, value)
    __swig_getmethods__ = {}
    for _s in [CsoundMidiOutputBuffer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundMidiOutputStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CsoundMidiOutputStream self, CSOUND * csound) -> CsoundMidiOutputStream
        __init__(CsoundMidiOutputStream self, Csound csound) -> CsoundMidiOutputStream
        """
        this = _csnd6.new_CsoundMidiOutputStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def EnableMidiOutput(self, argv):
        """EnableMidiOutput(CsoundMidiOutputStream self, CsoundArgVList argv)"""
        return _csnd6.CsoundMidiOutputStream_EnableMidiOutput(self, argv)

    __swig_destroy__ = _csnd6.delete_CsoundMidiOutputStream
    __del__ = lambda self: None
CsoundMidiOutputStream_swigregister = _csnd6.CsoundMidiOutputStream_swigregister
CsoundMidiOutputStream_swigregister(CsoundMidiOutputStream)

_MM_DENORMALS_ZERO_MASK = _csnd6._MM_DENORMALS_ZERO_MASK
_MM_DENORMALS_ZERO_ON = _csnd6._MM_DENORMALS_ZERO_ON
_MM_DENORMALS_ZERO_OFF = _csnd6._MM_DENORMALS_ZERO_OFF
class pycallbackdata(_object):
    """Proxy of C++ pycallbackdata class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pycallbackdata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pycallbackdata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["func"] = _csnd6.pycallbackdata_func_set
    __swig_getmethods__["func"] = _csnd6.pycallbackdata_func_get
    if _newclass:
        func = _swig_property(_csnd6.pycallbackdata_func_get, _csnd6.pycallbackdata_func_set)
    __swig_setmethods__["data"] = _csnd6.pycallbackdata_data_set
    __swig_getmethods__["data"] = _csnd6.pycallbackdata_data_get
    if _newclass:
        data = _swig_property(_csnd6.pycallbackdata_data_get, _csnd6.pycallbackdata_data_set)

    def __init__(self):
        """__init__(pycallbackdata self) -> pycallbackdata"""
        this = _csnd6.new_pycallbackdata()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_pycallbackdata
    __del__ = lambda self: None
pycallbackdata_swigregister = _csnd6.pycallbackdata_swigregister
pycallbackdata_swigregister(pycallbackdata)

class recordData_t(_object):
    """Proxy of C++ recordData_t class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, recordData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, recordData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["cbuf"] = _csnd6.recordData_t_cbuf_set
    __swig_getmethods__["cbuf"] = _csnd6.recordData_t_cbuf_get
    if _newclass:
        cbuf = _swig_property(_csnd6.recordData_t_cbuf_get, _csnd6.recordData_t_cbuf_set)
    __swig_setmethods__["sfile"] = _csnd6.recordData_t_sfile_set
    __swig_getmethods__["sfile"] = _csnd6.recordData_t_sfile_get
    if _newclass:
        sfile = _swig_property(_csnd6.recordData_t_sfile_get, _csnd6.recordData_t_sfile_set)
    __swig_setmethods__["thread"] = _csnd6.recordData_t_thread_set
    __swig_getmethods__["thread"] = _csnd6.recordData_t_thread_get
    if _newclass:
        thread = _swig_property(_csnd6.recordData_t_thread_get, _csnd6.recordData_t_thread_set)
    __swig_setmethods__["running"] = _csnd6.recordData_t_running_set
    __swig_getmethods__["running"] = _csnd6.recordData_t_running_get
    if _newclass:
        running = _swig_property(_csnd6.recordData_t_running_get, _csnd6.recordData_t_running_set)
    __swig_setmethods__["condvar"] = _csnd6.recordData_t_condvar_set
    __swig_getmethods__["condvar"] = _csnd6.recordData_t_condvar_get
    if _newclass:
        condvar = _swig_property(_csnd6.recordData_t_condvar_get, _csnd6.recordData_t_condvar_set)
    __swig_setmethods__["mutex"] = _csnd6.recordData_t_mutex_set
    __swig_getmethods__["mutex"] = _csnd6.recordData_t_mutex_get
    if _newclass:
        mutex = _swig_property(_csnd6.recordData_t_mutex_get, _csnd6.recordData_t_mutex_set)

    def __init__(self):
        """__init__(recordData_t self) -> recordData_t"""
        this = _csnd6.new_recordData_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_recordData_t
    __del__ = lambda self: None
recordData_t_swigregister = _csnd6.recordData_t_swigregister
recordData_t_swigregister(recordData_t)

class CsoundPerformanceThread(_object):
    """Proxy of C++ CsoundPerformanceThread class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundPerformanceThread, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundPerformanceThread, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_tstate"] = _csnd6.CsoundPerformanceThread__tstate_set
    __swig_getmethods__["_tstate"] = _csnd6.CsoundPerformanceThread__tstate_get
    if _newclass:
        _tstate = _swig_property(_csnd6.CsoundPerformanceThread__tstate_get, _csnd6.CsoundPerformanceThread__tstate_set)
    __swig_setmethods__["pydata"] = _csnd6.CsoundPerformanceThread_pydata_set
    __swig_getmethods__["pydata"] = _csnd6.CsoundPerformanceThread_pydata_get
    if _newclass:
        pydata = _swig_property(_csnd6.CsoundPerformanceThread_pydata_get, _csnd6.CsoundPerformanceThread_pydata_set)

    def isRunning(self):
        """isRunning(CsoundPerformanceThread self) -> int"""
        return _csnd6.CsoundPerformanceThread_isRunning(self)


    def GetProcessCallback(self):
        """GetProcessCallback(CsoundPerformanceThread self) -> void *"""
        return _csnd6.CsoundPerformanceThread_GetProcessCallback(self)


    def GetCsound(self):
        """GetCsound(CsoundPerformanceThread self) -> CSOUND *"""
        return _csnd6.CsoundPerformanceThread_GetCsound(self)


    def GetStatus(self):
        """GetStatus(CsoundPerformanceThread self) -> int"""
        return _csnd6.CsoundPerformanceThread_GetStatus(self)


    def Play(self):
        """Play(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_Play(self)


    def Pause(self):
        """Pause(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_Pause(self)


    def TogglePause(self):
        """TogglePause(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_TogglePause(self)


    def Stop(self):
        """Stop(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_Stop(self)


    def Record(self, filename, samplebits=16, numbufs=4):
        """
        Record(CsoundPerformanceThread self, std::string filename, int samplebits=16, int numbufs=4)
        Record(CsoundPerformanceThread self, std::string filename, int samplebits=16)
        Record(CsoundPerformanceThread self, std::string filename)
        """
        return _csnd6.CsoundPerformanceThread_Record(self, filename, samplebits, numbufs)


    def StopRecord(self):
        """StopRecord(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_StopRecord(self)


    def ScoreEvent(self, absp2mode, opcod, pcnt, p):
        """ScoreEvent(CsoundPerformanceThread self, int absp2mode, char opcod, int pcnt, double const * p)"""
        return _csnd6.CsoundPerformanceThread_ScoreEvent(self, absp2mode, opcod, pcnt, p)


    def InputMessage(self, s):
        """InputMessage(CsoundPerformanceThread self, char const * s)"""
        return _csnd6.CsoundPerformanceThread_InputMessage(self, s)


    def SetScoreOffsetSeconds(self, timeVal):
        """SetScoreOffsetSeconds(CsoundPerformanceThread self, double timeVal)"""
        return _csnd6.CsoundPerformanceThread_SetScoreOffsetSeconds(self, timeVal)


    def Join(self):
        """Join(CsoundPerformanceThread self) -> int"""
        return _csnd6.CsoundPerformanceThread_Join(self)


    def FlushMessageQueue(self):
        """FlushMessageQueue(CsoundPerformanceThread self)"""
        return _csnd6.CsoundPerformanceThread_FlushMessageQueue(self)


    def __init__(self, *args):
        """
        __init__(CsoundPerformanceThread self, Csound arg2) -> CsoundPerformanceThread
        __init__(CsoundPerformanceThread self, CSOUND * arg2) -> CsoundPerformanceThread
        """
        this = _csnd6.new_CsoundPerformanceThread(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundPerformanceThread
    __del__ = lambda self: None

    def SetProcessCallback(self, pyfunc, p):
        """SetProcessCallback(CsoundPerformanceThread self, PyObject * pyfunc, PyObject * p)"""
        return _csnd6.CsoundPerformanceThread_SetProcessCallback(self, pyfunc, p)

CsoundPerformanceThread_swigregister = _csnd6.CsoundPerformanceThread_swigregister
CsoundPerformanceThread_swigregister(CsoundPerformanceThread)

class IntToStringMap(_object):
    """Proxy of C++ std::map<(int,std::string)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntToStringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntToStringMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(IntToStringMap self) -> SwigPyIterator"""
        return _csnd6.IntToStringMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(IntToStringMap self) -> bool"""
        return _csnd6.IntToStringMap___nonzero__(self)


    def __bool__(self):
        """__bool__(IntToStringMap self) -> bool"""
        return _csnd6.IntToStringMap___bool__(self)


    def __len__(self):
        """__len__(IntToStringMap self) -> std::map< int,std::string >::size_type"""
        return _csnd6.IntToStringMap___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__(IntToStringMap self, std::map< int,std::string >::key_type const & key) -> std::map< int,std::string >::mapped_type const &"""
        return _csnd6.IntToStringMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(IntToStringMap self, std::map< int,std::string >::key_type const & key)"""
        return _csnd6.IntToStringMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(IntToStringMap self, std::map< int,std::string >::key_type const & key) -> bool"""
        return _csnd6.IntToStringMap_has_key(self, key)


    def keys(self):
        """keys(IntToStringMap self) -> PyObject *"""
        return _csnd6.IntToStringMap_keys(self)


    def values(self):
        """values(IntToStringMap self) -> PyObject *"""
        return _csnd6.IntToStringMap_values(self)


    def items(self):
        """items(IntToStringMap self) -> PyObject *"""
        return _csnd6.IntToStringMap_items(self)


    def __contains__(self, key):
        """__contains__(IntToStringMap self, std::map< int,std::string >::key_type const & key) -> bool"""
        return _csnd6.IntToStringMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(IntToStringMap self) -> SwigPyIterator"""
        return _csnd6.IntToStringMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(IntToStringMap self) -> SwigPyIterator"""
        return _csnd6.IntToStringMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(IntToStringMap self, std::map< int,std::string >::key_type const & key)
        __setitem__(IntToStringMap self, std::map< int,std::string >::key_type const & key, std::map< int,std::string >::mapped_type const & x)
        """
        return _csnd6.IntToStringMap___setitem__(self, *args)


    def asdict(self):
        """asdict(IntToStringMap self) -> PyObject *"""
        return _csnd6.IntToStringMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(int,std::string)> self, std::less< int > const & arg2) -> IntToStringMap
        __init__(std::map<(int,std::string)> self) -> IntToStringMap
        __init__(std::map<(int,std::string)> self, IntToStringMap arg2) -> IntToStringMap
        """
        this = _csnd6.new_IntToStringMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(IntToStringMap self) -> bool"""
        return _csnd6.IntToStringMap_empty(self)


    def size(self):
        """size(IntToStringMap self) -> std::map< int,std::string >::size_type"""
        return _csnd6.IntToStringMap_size(self)


    def swap(self, v):
        """swap(IntToStringMap self, IntToStringMap v)"""
        return _csnd6.IntToStringMap_swap(self, v)


    def begin(self):
        """begin(IntToStringMap self) -> std::map< int,std::string >::iterator"""
        return _csnd6.IntToStringMap_begin(self)


    def end(self):
        """end(IntToStringMap self) -> std::map< int,std::string >::iterator"""
        return _csnd6.IntToStringMap_end(self)


    def rbegin(self):
        """rbegin(IntToStringMap self) -> std::map< int,std::string >::reverse_iterator"""
        return _csnd6.IntToStringMap_rbegin(self)


    def rend(self):
        """rend(IntToStringMap self) -> std::map< int,std::string >::reverse_iterator"""
        return _csnd6.IntToStringMap_rend(self)


    def clear(self):
        """clear(IntToStringMap self)"""
        return _csnd6.IntToStringMap_clear(self)


    def get_allocator(self):
        """get_allocator(IntToStringMap self) -> std::map< int,std::string >::allocator_type"""
        return _csnd6.IntToStringMap_get_allocator(self)


    def count(self, x):
        """count(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::size_type"""
        return _csnd6.IntToStringMap_count(self, x)


    def erase(self, *args):
        """
        erase(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::size_type
        erase(IntToStringMap self, std::map< int,std::string >::iterator position)
        erase(IntToStringMap self, std::map< int,std::string >::iterator first, std::map< int,std::string >::iterator last)
        """
        return _csnd6.IntToStringMap_erase(self, *args)


    def find(self, x):
        """find(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::iterator"""
        return _csnd6.IntToStringMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::iterator"""
        return _csnd6.IntToStringMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::iterator"""
        return _csnd6.IntToStringMap_upper_bound(self, x)

    __swig_destroy__ = _csnd6.delete_IntToStringMap
    __del__ = lambda self: None
IntToStringMap_swigregister = _csnd6.IntToStringMap_swigregister
IntToStringMap_swigregister(IntToStringMap)


def gatherArgs(argc, argv, commandLine):
    """gatherArgs(int argc, char const ** argv, std::string & commandLine)"""
    return _csnd6.gatherArgs(argc, argv, commandLine)

def scatterArgs(commandLine, args, argv):
    """scatterArgs(std::string const commandLine, std::vector< std::string,std::allocator< std::string > > & args, std::vector< char *,std::allocator< char * > > & argv)"""
    return _csnd6.scatterArgs(commandLine, args, argv)

def trim(value):
    """trim(std::string & value) -> std::string &"""
    return _csnd6.trim(value)

def trimQuotes(value):
    """trimQuotes(std::string & value) -> std::string &"""
    return _csnd6.trimQuotes(value)

def parseInstrument(definition, preNumber, id, name, postNumber):
    """parseInstrument(std::string const & definition, std::string & preNumber, std::string & id, std::string & name, std::string & postNumber) -> bool"""
    return _csnd6.parseInstrument(definition, preNumber, id, name, postNumber)
class CsoundFile(_object):
    """Proxy of C++ CsoundFile class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundFile, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundFile, name)
    __repr__ = _swig_repr
    __swig_setmethods__["libraryFilename"] = _csnd6.CsoundFile_libraryFilename_set
    __swig_getmethods__["libraryFilename"] = _csnd6.CsoundFile_libraryFilename_get
    if _newclass:
        libraryFilename = _swig_property(_csnd6.CsoundFile_libraryFilename_get, _csnd6.CsoundFile_libraryFilename_set)
    __swig_setmethods__["arrangement"] = _csnd6.CsoundFile_arrangement_set
    __swig_getmethods__["arrangement"] = _csnd6.CsoundFile_arrangement_get
    if _newclass:
        arrangement = _swig_property(_csnd6.CsoundFile_arrangement_get, _csnd6.CsoundFile_arrangement_set)

    def __init__(self):
        """__init__(CsoundFile self) -> CsoundFile"""
        this = _csnd6.new_CsoundFile()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CsoundFile
    __del__ = lambda self: None

    def generateFilename(self):
        """generateFilename(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_generateFilename(self)


    def getFilename(self):
        """getFilename(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getFilename(self)


    def setFilename(self, name):
        """setFilename(CsoundFile self, std::string name)"""
        return _csnd6.CsoundFile_setFilename(self, name)


    def load(self, *args):
        """
        load(CsoundFile self, std::string filename) -> int
        load(CsoundFile self, std::istream & stream) -> int
        """
        return _csnd6.CsoundFile_load(self, *args)


    def save(self, *args):
        """
        save(CsoundFile self, std::string filename) -> int
        save(CsoundFile self, std::ostream & stream) -> int
        """
        return _csnd6.CsoundFile_save(self, *args)


    def importFile(self, *args):
        """
        importFile(CsoundFile self, std::string filename) -> int
        importFile(CsoundFile self, std::istream & stream) -> int
        """
        return _csnd6.CsoundFile_importFile(self, *args)


    def importCommand(self, stream):
        """importCommand(CsoundFile self, std::istream & stream) -> int"""
        return _csnd6.CsoundFile_importCommand(self, stream)


    def exportCommand(self, stream):
        """exportCommand(CsoundFile self, std::ostream & stream) -> int"""
        return _csnd6.CsoundFile_exportCommand(self, stream)


    def importOrchestra(self, stream):
        """importOrchestra(CsoundFile self, std::istream & stream) -> int"""
        return _csnd6.CsoundFile_importOrchestra(self, stream)


    def exportOrchestra(self, stream):
        """exportOrchestra(CsoundFile self, std::ostream & stream) -> int"""
        return _csnd6.CsoundFile_exportOrchestra(self, stream)


    def importScore(self, stream):
        """importScore(CsoundFile self, std::istream & stream) -> int"""
        return _csnd6.CsoundFile_importScore(self, stream)


    def exportScore(self, stream):
        """exportScore(CsoundFile self, std::ostream & stream) -> int"""
        return _csnd6.CsoundFile_exportScore(self, stream)


    def importArrangement(self, stream):
        """importArrangement(CsoundFile self, std::istream & stream) -> int"""
        return _csnd6.CsoundFile_importArrangement(self, stream)


    def exportArrangement(self, stream):
        """exportArrangement(CsoundFile self, std::ostream & stream) -> int"""
        return _csnd6.CsoundFile_exportArrangement(self, stream)


    def exportArrangementForPerformance(self, *args):
        """
        exportArrangementForPerformance(CsoundFile self, std::string filename) -> int
        exportArrangementForPerformance(CsoundFile self, std::ostream & stream) -> int
        """
        return _csnd6.CsoundFile_exportArrangementForPerformance(self, *args)


    def importMidifile(self, stream):
        """importMidifile(CsoundFile self, std::istream & stream) -> int"""
        return _csnd6.CsoundFile_importMidifile(self, stream)


    def exportMidifile(self, stream):
        """exportMidifile(CsoundFile self, std::ostream & stream) -> int"""
        return _csnd6.CsoundFile_exportMidifile(self, stream)


    def getCommand(self):
        """getCommand(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getCommand(self)


    def setCommand(self, commandLine):
        """setCommand(CsoundFile self, std::string commandLine)"""
        return _csnd6.CsoundFile_setCommand(self, commandLine)


    def getOrcFilename(self):
        """getOrcFilename(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getOrcFilename(self)


    def getScoFilename(self):
        """getScoFilename(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getScoFilename(self)


    def getMidiFilename(self):
        """getMidiFilename(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getMidiFilename(self)


    def getOutputSoundfileName(self):
        """getOutputSoundfileName(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getOutputSoundfileName(self)


    def getOrchestra(self):
        """getOrchestra(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getOrchestra(self)


    def setOrchestra(self, orchestra):
        """setOrchestra(CsoundFile self, std::string orchestra)"""
        return _csnd6.CsoundFile_setOrchestra(self, orchestra)


    def getInstrumentCount(self):
        """getInstrumentCount(CsoundFile self) -> int"""
        return _csnd6.CsoundFile_getInstrumentCount(self)


    def getOrchestraHeader(self):
        """getOrchestraHeader(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getOrchestraHeader(self)


    def getInstrument(self, *args):
        """
        getInstrument(CsoundFile self, int number, std::string & definition) -> bool
        getInstrument(CsoundFile self, std::string name, std::string & definition) -> bool
        getInstrument(CsoundFile self, std::string name) -> std::string
        getInstrument(CsoundFile self, int number) -> std::string
        """
        return _csnd6.CsoundFile_getInstrument(self, *args)


    def getInstrumentBody(self, *args):
        """
        getInstrumentBody(CsoundFile self, std::string name) -> std::string
        getInstrumentBody(CsoundFile self, int number) -> std::string
        """
        return _csnd6.CsoundFile_getInstrumentBody(self, *args)


    def getInstrumentNames(self):
        """getInstrumentNames(CsoundFile self) -> IntToStringMap"""
        return _csnd6.CsoundFile_getInstrumentNames(self)


    def getInstrumentNumber(self, name):
        """getInstrumentNumber(CsoundFile self, std::string name) -> double"""
        return _csnd6.CsoundFile_getInstrumentNumber(self, name)


    def getScore(self):
        """getScore(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getScore(self)


    def setScore(self, score):
        """setScore(CsoundFile self, std::string score)"""
        return _csnd6.CsoundFile_setScore(self, score)


    def getArrangementCount(self):
        """getArrangementCount(CsoundFile self) -> int"""
        return _csnd6.CsoundFile_getArrangementCount(self)


    def getArrangement(self, index):
        """getArrangement(CsoundFile self, int index) -> std::string"""
        return _csnd6.CsoundFile_getArrangement(self, index)


    def addArrangement(self, instrument):
        """addArrangement(CsoundFile self, std::string instrument)"""
        return _csnd6.CsoundFile_addArrangement(self, instrument)


    def setArrangement(self, index, instrument):
        """setArrangement(CsoundFile self, int index, std::string instrument)"""
        return _csnd6.CsoundFile_setArrangement(self, index, instrument)


    def insertArrangement(self, index, instrument):
        """insertArrangement(CsoundFile self, int index, std::string instrument)"""
        return _csnd6.CsoundFile_insertArrangement(self, index, instrument)


    def setCSD(self, xml):
        """setCSD(CsoundFile self, std::string xml)"""
        return _csnd6.CsoundFile_setCSD(self, xml)


    def getCSD(self):
        """getCSD(CsoundFile self) -> std::string"""
        return _csnd6.CsoundFile_getCSD(self)


    def addScoreLine(self, line):
        """addScoreLine(CsoundFile self, std::string const line)"""
        return _csnd6.CsoundFile_addScoreLine(self, line)


    def addNote(self, *args):
        """
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6, double p7, double p8, double p9, double p10, double p11)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6, double p7, double p8, double p9, double p10)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6, double p7, double p8, double p9)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6, double p7, double p8)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6, double p7)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5, double p6)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4, double p5)
        addNote(CsoundFile self, double p1, double p2, double p3, double p4)
        addNote(CsoundFile self, double p1, double p2, double p3)
        """
        return _csnd6.CsoundFile_addNote(self, *args)


    def exportForPerformance(self):
        """exportForPerformance(CsoundFile self) -> bool"""
        return _csnd6.CsoundFile_exportForPerformance(self)


    def removeAll(self):
        """removeAll(CsoundFile self)"""
        return _csnd6.CsoundFile_removeAll(self)


    def removeCommand(self):
        """removeCommand(CsoundFile self)"""
        return _csnd6.CsoundFile_removeCommand(self)


    def removeOrchestra(self):
        """removeOrchestra(CsoundFile self)"""
        return _csnd6.CsoundFile_removeOrchestra(self)


    def removeScore(self):
        """removeScore(CsoundFile self)"""
        return _csnd6.CsoundFile_removeScore(self)


    def removeArrangement(self, *args):
        """
        removeArrangement(CsoundFile self, int index)
        removeArrangement(CsoundFile self)
        """
        return _csnd6.CsoundFile_removeArrangement(self, *args)


    def removeMidifile(self):
        """removeMidifile(CsoundFile self)"""
        return _csnd6.CsoundFile_removeMidifile(self)


    def loadOrcLibrary(self, filename=None):
        """
        loadOrcLibrary(CsoundFile self, char const * filename=None) -> bool
        loadOrcLibrary(CsoundFile self) -> bool
        """
        return _csnd6.CsoundFile_loadOrcLibrary(self, filename)

CsoundFile_swigregister = _csnd6.CsoundFile_swigregister
CsoundFile_swigregister(CsoundFile)

class MyfltVector(_object):
    """Proxy of C++ std::vector<(double)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MyfltVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MyfltVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(MyfltVector self) -> SwigPyIterator"""
        return _csnd6.MyfltVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(MyfltVector self) -> bool"""
        return _csnd6.MyfltVector___nonzero__(self)


    def __bool__(self):
        """__bool__(MyfltVector self) -> bool"""
        return _csnd6.MyfltVector___bool__(self)


    def __len__(self):
        """__len__(MyfltVector self) -> std::vector< double >::size_type"""
        return _csnd6.MyfltVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MyfltVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> MyfltVector"""
        return _csnd6.MyfltVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MyfltVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(MyfltVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, MyfltVector v)
        """
        return _csnd6.MyfltVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MyfltVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _csnd6.MyfltVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MyfltVector self, std::vector< double >::difference_type i)
        __delitem__(MyfltVector self, PySliceObject * slice)
        """
        return _csnd6.MyfltVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MyfltVector self, PySliceObject * slice) -> MyfltVector
        __getitem__(MyfltVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _csnd6.MyfltVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MyfltVector self, PySliceObject * slice, MyfltVector v)
        __setitem__(MyfltVector self, PySliceObject * slice)
        __setitem__(MyfltVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _csnd6.MyfltVector___setitem__(self, *args)


    def pop(self):
        """pop(MyfltVector self) -> std::vector< double >::value_type"""
        return _csnd6.MyfltVector_pop(self)


    def append(self, x):
        """append(MyfltVector self, std::vector< double >::value_type const & x)"""
        return _csnd6.MyfltVector_append(self, x)


    def empty(self):
        """empty(MyfltVector self) -> bool"""
        return _csnd6.MyfltVector_empty(self)


    def size(self):
        """size(MyfltVector self) -> std::vector< double >::size_type"""
        return _csnd6.MyfltVector_size(self)


    def swap(self, v):
        """swap(MyfltVector self, MyfltVector v)"""
        return _csnd6.MyfltVector_swap(self, v)


    def begin(self):
        """begin(MyfltVector self) -> std::vector< double >::iterator"""
        return _csnd6.MyfltVector_begin(self)


    def end(self):
        """end(MyfltVector self) -> std::vector< double >::iterator"""
        return _csnd6.MyfltVector_end(self)


    def rbegin(self):
        """rbegin(MyfltVector self) -> std::vector< double >::reverse_iterator"""
        return _csnd6.MyfltVector_rbegin(self)


    def rend(self):
        """rend(MyfltVector self) -> std::vector< double >::reverse_iterator"""
        return _csnd6.MyfltVector_rend(self)


    def clear(self):
        """clear(MyfltVector self)"""
        return _csnd6.MyfltVector_clear(self)


    def get_allocator(self):
        """get_allocator(MyfltVector self) -> std::vector< double >::allocator_type"""
        return _csnd6.MyfltVector_get_allocator(self)


    def pop_back(self):
        """pop_back(MyfltVector self)"""
        return _csnd6.MyfltVector_pop_back(self)


    def erase(self, *args):
        """
        erase(MyfltVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(MyfltVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _csnd6.MyfltVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> MyfltVector
        __init__(std::vector<(double)> self, MyfltVector arg2) -> MyfltVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> MyfltVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> MyfltVector
        """
        this = _csnd6.new_MyfltVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(MyfltVector self, std::vector< double >::value_type const & x)"""
        return _csnd6.MyfltVector_push_back(self, x)


    def front(self):
        """front(MyfltVector self) -> std::vector< double >::value_type const &"""
        return _csnd6.MyfltVector_front(self)


    def back(self):
        """back(MyfltVector self) -> std::vector< double >::value_type const &"""
        return _csnd6.MyfltVector_back(self)


    def assign(self, n, x):
        """assign(MyfltVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _csnd6.MyfltVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MyfltVector self, std::vector< double >::size_type new_size)
        resize(MyfltVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _csnd6.MyfltVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(MyfltVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(MyfltVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _csnd6.MyfltVector_insert(self, *args)


    def reserve(self, n):
        """reserve(MyfltVector self, std::vector< double >::size_type n)"""
        return _csnd6.MyfltVector_reserve(self, n)


    def capacity(self):
        """capacity(MyfltVector self) -> std::vector< double >::size_type"""
        return _csnd6.MyfltVector_capacity(self)

    __swig_destroy__ = _csnd6.delete_MyfltVector
    __del__ = lambda self: None
MyfltVector_swigregister = _csnd6.MyfltVector_swigregister
MyfltVector_swigregister(MyfltVector)

class CppSound(Csound, CsoundFile):
    """Proxy of C++ CppSound class."""

    __swig_setmethods__ = {}
    for _s in [Csound, CsoundFile]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CppSound, name, value)
    __swig_getmethods__ = {}
    for _s in [Csound, CsoundFile]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CppSound, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(CppSound self) -> CppSound"""
        this = _csnd6.new_CppSound()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _csnd6.delete_CppSound
    __del__ = lambda self: None

    def getCsound(self):
        """getCsound(CppSound self) -> CSOUND *"""
        return _csnd6.CppSound_getCsound(self)


    def getThis(self):
        """getThis(CppSound self) -> intptr_t"""
        return _csnd6.CppSound_getThis(self)


    def getCsoundFile(self):
        """getCsoundFile(CppSound self) -> CsoundFile"""
        return _csnd6.CppSound_getCsoundFile(self)


    def compile(self, *args):
        """
        compile(CppSound self, int argc, char const ** argv) -> int
        compile(CppSound self) -> int
        """
        return _csnd6.CppSound_compile(self, *args)


    def getSpoutSize(self):
        """getSpoutSize(CppSound self) -> size_t"""
        return _csnd6.CppSound_getSpoutSize(self)


    def getOutputSoundfileName(self):
        """getOutputSoundfileName(CppSound self) -> std::string"""
        return _csnd6.CppSound_getOutputSoundfileName(self)


    def perform(self, *args):
        """
        perform(CppSound self, int argc, char const ** argv) -> int
        perform(CppSound self) -> int
        """
        return _csnd6.CppSound_perform(self, *args)


    def performKsmps(self):
        """performKsmps(CppSound self) -> int"""
        return _csnd6.CppSound_performKsmps(self)


    def cleanup(self):
        """cleanup(CppSound self)"""
        return _csnd6.CppSound_cleanup(self)


    def inputMessage(self, istatement):
        """inputMessage(CppSound self, char const * istatement)"""
        return _csnd6.CppSound_inputMessage(self, istatement)


    def write(self, text):
        """write(CppSound self, char const * text)"""
        return _csnd6.CppSound_write(self, text)


    def getIsCompiled(self):
        """getIsCompiled(CppSound self) -> bool"""
        return _csnd6.CppSound_getIsCompiled(self)


    def setIsPerforming(self, isPerforming):
        """setIsPerforming(CppSound self, bool isPerforming)"""
        return _csnd6.CppSound_setIsPerforming(self, isPerforming)


    def getIsPerforming(self):
        """getIsPerforming(CppSound self) -> bool"""
        return _csnd6.CppSound_getIsPerforming(self)


    def getIsGo(self):
        """getIsGo(CppSound self) -> bool"""
        return _csnd6.CppSound_getIsGo(self)


    def stop(self):
        """stop(CppSound self)"""
        return _csnd6.CppSound_stop(self)


    def setPythonMessageCallback(self):
        """setPythonMessageCallback(CppSound self)"""
        return _csnd6.CppSound_setPythonMessageCallback(self)

CppSound_swigregister = _csnd6.CppSound_swigregister
CppSound_swigregister(CppSound)

# This file is compatible with both classic and new-style classes.


