# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.39
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

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

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

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

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

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    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")
    __repr__ = _swig_repr
    __swig_destroy__ = _csnd.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _csnd.SwigPyIterator_value(self)
    def incr(self, n = 1): return _csnd.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _csnd.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _csnd.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _csnd.SwigPyIterator_equal(self, *args)
    def copy(self): return _csnd.SwigPyIterator_copy(self)
    def next(self): return _csnd.SwigPyIterator_next(self)
    def __next__(self): return _csnd.SwigPyIterator___next__(self)
    def previous(self): return _csnd.SwigPyIterator_previous(self)
    def advance(self, *args): return _csnd.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _csnd.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _csnd.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _csnd.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _csnd.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _csnd.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _csnd.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _csnd.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def new_intp(*args):
  return _csnd.new_intp(*args)
new_intp = _csnd.new_intp

def delete_intp(*args):
  return _csnd.delete_intp(*args)
delete_intp = _csnd.delete_intp

def intp_getitem(*args):
  return _csnd.intp_getitem(*args)
intp_getitem = _csnd.intp_getitem

def intp_setitem(*args):
  return _csnd.intp_setitem(*args)
intp_setitem = _csnd.intp_setitem

def new_floatp(*args):
  return _csnd.new_floatp(*args)
new_floatp = _csnd.new_floatp

def delete_floatp(*args):
  return _csnd.delete_floatp(*args)
delete_floatp = _csnd.delete_floatp

def floatp_getitem(*args):
  return _csnd.floatp_getitem(*args)
floatp_getitem = _csnd.floatp_getitem

def floatp_setitem(*args):
  return _csnd.floatp_setitem(*args)
floatp_setitem = _csnd.floatp_setitem

def new_doublep(*args):
  return _csnd.new_doublep(*args)
new_doublep = _csnd.new_doublep

def delete_doublep(*args):
  return _csnd.delete_doublep(*args)
delete_doublep = _csnd.delete_doublep

def doublep_getitem(*args):
  return _csnd.doublep_getitem(*args)
doublep_getitem = _csnd.doublep_getitem

def doublep_setitem(*args):
  return _csnd.doublep_setitem(*args)
doublep_setitem = _csnd.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, *args): 
        this = _csnd.new_intArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_intArray
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _csnd.intArray___getitem__(self, *args)
    def __setitem__(self, *args): return _csnd.intArray___setitem__(self, *args)
    def cast(self): return _csnd.intArray_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _csnd.intArray_frompointer
    if _newclass:frompointer = staticmethod(_csnd.intArray_frompointer)
intArray_swigregister = _csnd.intArray_swigregister
intArray_swigregister(intArray)

def intArray_frompointer(*args):
  return _csnd.intArray_frompointer(*args)
intArray_frompointer = _csnd.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, *args): 
        this = _csnd.new_floatArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_floatArray
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _csnd.floatArray___getitem__(self, *args)
    def __setitem__(self, *args): return _csnd.floatArray___setitem__(self, *args)
    def cast(self): return _csnd.floatArray_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _csnd.floatArray_frompointer
    if _newclass:frompointer = staticmethod(_csnd.floatArray_frompointer)
floatArray_swigregister = _csnd.floatArray_swigregister
floatArray_swigregister(floatArray)

def floatArray_frompointer(*args):
  return _csnd.floatArray_frompointer(*args)
floatArray_frompointer = _csnd.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, *args): 
        this = _csnd.new_doubleArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_doubleArray
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _csnd.doubleArray___getitem__(self, *args)
    def __setitem__(self, *args): return _csnd.doubleArray___setitem__(self, *args)
    def cast(self): return _csnd.doubleArray_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _csnd.doubleArray_frompointer
    if _newclass:frompointer = staticmethod(_csnd.doubleArray_frompointer)
doubleArray_swigregister = _csnd.doubleArray_swigregister
doubleArray_swigregister(doubleArray)

def doubleArray_frompointer(*args):
  return _csnd.doubleArray_frompointer(*args)
doubleArray_frompointer = _csnd.doubleArray_frompointer

CSOUND_SUCCESS = _csnd.CSOUND_SUCCESS
CSOUND_ERROR = _csnd.CSOUND_ERROR
CSOUND_INITIALIZATION = _csnd.CSOUND_INITIALIZATION
CSOUND_PERFORMANCE = _csnd.CSOUND_PERFORMANCE
CSOUND_MEMORY = _csnd.CSOUND_MEMORY
CSOUND_SIGNAL = _csnd.CSOUND_SIGNAL
CSOUND_EXITJMP_SUCCESS = _csnd.CSOUND_EXITJMP_SUCCESS
CSOUNDINIT_NO_SIGNAL_HANDLER = _csnd.CSOUNDINIT_NO_SIGNAL_HANDLER
CSOUNDINIT_NO_ATEXIT = _csnd.CSOUNDINIT_NO_ATEXIT
CSOUND_CONTROL_CHANNEL = _csnd.CSOUND_CONTROL_CHANNEL
CSOUND_AUDIO_CHANNEL = _csnd.CSOUND_AUDIO_CHANNEL
CSOUND_STRING_CHANNEL = _csnd.CSOUND_STRING_CHANNEL
CSOUND_CHANNEL_TYPE_MASK = _csnd.CSOUND_CHANNEL_TYPE_MASK
CSOUND_INPUT_CHANNEL = _csnd.CSOUND_INPUT_CHANNEL
CSOUND_OUTPUT_CHANNEL = _csnd.CSOUND_OUTPUT_CHANNEL
CSOUND_CONTROL_CHANNEL_INT = _csnd.CSOUND_CONTROL_CHANNEL_INT
CSOUND_CONTROL_CHANNEL_LIN = _csnd.CSOUND_CONTROL_CHANNEL_LIN
CSOUND_CONTROL_CHANNEL_EXP = _csnd.CSOUND_CONTROL_CHANNEL_EXP
CSOUND_CALLBACK_KBD_EVENT = _csnd.CSOUND_CALLBACK_KBD_EVENT
CSOUND_CALLBACK_KBD_TEXT = _csnd.CSOUND_CALLBACK_KBD_TEXT
CSFTYPE_UNIFIED_CSD = _csnd.CSFTYPE_UNIFIED_CSD
CSFTYPE_ORCHESTRA = _csnd.CSFTYPE_ORCHESTRA
CSFTYPE_SCORE = _csnd.CSFTYPE_SCORE
CSFTYPE_ORC_INCLUDE = _csnd.CSFTYPE_ORC_INCLUDE
CSFTYPE_SCO_INCLUDE = _csnd.CSFTYPE_SCO_INCLUDE
CSFTYPE_SCORE_OUT = _csnd.CSFTYPE_SCORE_OUT
CSFTYPE_SCOT = _csnd.CSFTYPE_SCOT
CSFTYPE_OPTIONS = _csnd.CSFTYPE_OPTIONS
CSFTYPE_EXTRACT_PARMS = _csnd.CSFTYPE_EXTRACT_PARMS
CSFTYPE_RAW_AUDIO = _csnd.CSFTYPE_RAW_AUDIO
CSFTYPE_IRCAM = _csnd.CSFTYPE_IRCAM
CSFTYPE_AIFF = _csnd.CSFTYPE_AIFF
CSFTYPE_AIFC = _csnd.CSFTYPE_AIFC
CSFTYPE_WAVE = _csnd.CSFTYPE_WAVE
CSFTYPE_AU = _csnd.CSFTYPE_AU
CSFTYPE_SD2 = _csnd.CSFTYPE_SD2
CSFTYPE_W64 = _csnd.CSFTYPE_W64
CSFTYPE_WAVEX = _csnd.CSFTYPE_WAVEX
CSFTYPE_FLAC = _csnd.CSFTYPE_FLAC
CSFTYPE_CAF = _csnd.CSFTYPE_CAF
CSFTYPE_AVR = _csnd.CSFTYPE_AVR
CSFTYPE_HTK = _csnd.CSFTYPE_HTK
CSFTYPE_MAT4 = _csnd.CSFTYPE_MAT4
CSFTYPE_MAT5 = _csnd.CSFTYPE_MAT5
CSFTYPE_NIST = _csnd.CSFTYPE_NIST
CSFTYPE_PAF = _csnd.CSFTYPE_PAF
CSFTYPE_PVF = _csnd.CSFTYPE_PVF
CSFTYPE_SDS = _csnd.CSFTYPE_SDS
CSFTYPE_SVX = _csnd.CSFTYPE_SVX
CSFTYPE_VOC = _csnd.CSFTYPE_VOC
CSFTYPE_XI = _csnd.CSFTYPE_XI
CSFTYPE_UNKNOWN_AUDIO = _csnd.CSFTYPE_UNKNOWN_AUDIO
CSFTYPE_SOUNDFONT = _csnd.CSFTYPE_SOUNDFONT
CSFTYPE_STD_MIDI = _csnd.CSFTYPE_STD_MIDI
CSFTYPE_MIDI_SYSEX = _csnd.CSFTYPE_MIDI_SYSEX
CSFTYPE_HETRO = _csnd.CSFTYPE_HETRO
CSFTYPE_PVC = _csnd.CSFTYPE_PVC
CSFTYPE_PVCEX = _csnd.CSFTYPE_PVCEX
CSFTYPE_CVANAL = _csnd.CSFTYPE_CVANAL
CSFTYPE_LPC = _csnd.CSFTYPE_LPC
CSFTYPE_ATS = _csnd.CSFTYPE_ATS
CSFTYPE_LORIS = _csnd.CSFTYPE_LORIS
CSFTYPE_SDIF = _csnd.CSFTYPE_SDIF
CSFTYPE_HRTF = _csnd.CSFTYPE_HRTF
CSFTYPE_VST_PLUGIN = _csnd.CSFTYPE_VST_PLUGIN
CSFTYPE_LADSPA_PLUGIN = _csnd.CSFTYPE_LADSPA_PLUGIN
CSFTYPE_SNAPSHOT = _csnd.CSFTYPE_SNAPSHOT
CSFTYPE_FTABLES_TEXT = _csnd.CSFTYPE_FTABLES_TEXT
CSFTYPE_FTABLES_BINARY = _csnd.CSFTYPE_FTABLES_BINARY
CSFTYPE_XSCANU_MATRIX = _csnd.CSFTYPE_XSCANU_MATRIX
CSFTYPE_FLOATS_TEXT = _csnd.CSFTYPE_FLOATS_TEXT
CSFTYPE_FLOATS_BINARY = _csnd.CSFTYPE_FLOATS_BINARY
CSFTYPE_INTEGER_TEXT = _csnd.CSFTYPE_INTEGER_TEXT
CSFTYPE_INTEGER_BINARY = _csnd.CSFTYPE_INTEGER_BINARY
CSFTYPE_POSTSCRIPT = _csnd.CSFTYPE_POSTSCRIPT
CSFTYPE_SCRIPT_TEXT = _csnd.CSFTYPE_SCRIPT_TEXT
CSFTYPE_OTHER_TEXT = _csnd.CSFTYPE_OTHER_TEXT
CSFTYPE_OTHER_BINARY = _csnd.CSFTYPE_OTHER_BINARY
CSFTYPE_UNKNOWN = _csnd.CSFTYPE_UNKNOWN
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"] = _csnd.csRtAudioParams_devName_set
    __swig_getmethods__["devName"] = _csnd.csRtAudioParams_devName_get
    if _newclass:devName = _swig_property(_csnd.csRtAudioParams_devName_get, _csnd.csRtAudioParams_devName_set)
    __swig_setmethods__["devNum"] = _csnd.csRtAudioParams_devNum_set
    __swig_getmethods__["devNum"] = _csnd.csRtAudioParams_devNum_get
    if _newclass:devNum = _swig_property(_csnd.csRtAudioParams_devNum_get, _csnd.csRtAudioParams_devNum_set)
    __swig_setmethods__["bufSamp_SW"] = _csnd.csRtAudioParams_bufSamp_SW_set
    __swig_getmethods__["bufSamp_SW"] = _csnd.csRtAudioParams_bufSamp_SW_get
    if _newclass:bufSamp_SW = _swig_property(_csnd.csRtAudioParams_bufSamp_SW_get, _csnd.csRtAudioParams_bufSamp_SW_set)
    __swig_setmethods__["bufSamp_HW"] = _csnd.csRtAudioParams_bufSamp_HW_set
    __swig_getmethods__["bufSamp_HW"] = _csnd.csRtAudioParams_bufSamp_HW_get
    if _newclass:bufSamp_HW = _swig_property(_csnd.csRtAudioParams_bufSamp_HW_get, _csnd.csRtAudioParams_bufSamp_HW_set)
    __swig_setmethods__["nChannels"] = _csnd.csRtAudioParams_nChannels_set
    __swig_getmethods__["nChannels"] = _csnd.csRtAudioParams_nChannels_get
    if _newclass:nChannels = _swig_property(_csnd.csRtAudioParams_nChannels_get, _csnd.csRtAudioParams_nChannels_set)
    __swig_setmethods__["sampleFormat"] = _csnd.csRtAudioParams_sampleFormat_set
    __swig_getmethods__["sampleFormat"] = _csnd.csRtAudioParams_sampleFormat_get
    if _newclass:sampleFormat = _swig_property(_csnd.csRtAudioParams_sampleFormat_get, _csnd.csRtAudioParams_sampleFormat_set)
    __swig_setmethods__["sampleRate"] = _csnd.csRtAudioParams_sampleRate_set
    __swig_getmethods__["sampleRate"] = _csnd.csRtAudioParams_sampleRate_get
    if _newclass:sampleRate = _swig_property(_csnd.csRtAudioParams_sampleRate_get, _csnd.csRtAudioParams_sampleRate_set)
    def __init__(self): 
        """__init__(self) -> csRtAudioParams"""
        this = _csnd.new_csRtAudioParams()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csRtAudioParams
    __del__ = lambda self : None;
csRtAudioParams_swigregister = _csnd.csRtAudioParams_swigregister
csRtAudioParams_swigregister(csRtAudioParams)

class RTCLOCK(_object):
    """Proxy of C++ RTCLOCK 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"] = _csnd.RTCLOCK_starttime_real_set
    __swig_getmethods__["starttime_real"] = _csnd.RTCLOCK_starttime_real_get
    if _newclass:starttime_real = _swig_property(_csnd.RTCLOCK_starttime_real_get, _csnd.RTCLOCK_starttime_real_set)
    __swig_setmethods__["starttime_CPU"] = _csnd.RTCLOCK_starttime_CPU_set
    __swig_getmethods__["starttime_CPU"] = _csnd.RTCLOCK_starttime_CPU_get
    if _newclass:starttime_CPU = _swig_property(_csnd.RTCLOCK_starttime_CPU_get, _csnd.RTCLOCK_starttime_CPU_set)
    def __init__(self): 
        """__init__(self) -> RTCLOCK"""
        this = _csnd.new_RTCLOCK()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_RTCLOCK
    __del__ = lambda self : None;
RTCLOCK_swigregister = _csnd.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"] = _csnd.opcodeListEntry_opname_set
    __swig_getmethods__["opname"] = _csnd.opcodeListEntry_opname_get
    if _newclass:opname = _swig_property(_csnd.opcodeListEntry_opname_get, _csnd.opcodeListEntry_opname_set)
    __swig_setmethods__["outypes"] = _csnd.opcodeListEntry_outypes_set
    __swig_getmethods__["outypes"] = _csnd.opcodeListEntry_outypes_get
    if _newclass:outypes = _swig_property(_csnd.opcodeListEntry_outypes_get, _csnd.opcodeListEntry_outypes_set)
    __swig_setmethods__["intypes"] = _csnd.opcodeListEntry_intypes_set
    __swig_getmethods__["intypes"] = _csnd.opcodeListEntry_intypes_get
    if _newclass:intypes = _swig_property(_csnd.opcodeListEntry_intypes_get, _csnd.opcodeListEntry_intypes_set)
    def __init__(self): 
        """__init__(self) -> opcodeListEntry"""
        this = _csnd.new_opcodeListEntry()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_opcodeListEntry
    __del__ = lambda self : None;
opcodeListEntry_swigregister = _csnd.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"] = _csnd.CsoundRandMTState_mti_set
    __swig_getmethods__["mti"] = _csnd.CsoundRandMTState_mti_get
    if _newclass:mti = _swig_property(_csnd.CsoundRandMTState_mti_get, _csnd.CsoundRandMTState_mti_set)
    __swig_setmethods__["mt"] = _csnd.CsoundRandMTState_mt_set
    __swig_getmethods__["mt"] = _csnd.CsoundRandMTState_mt_get
    if _newclass:mt = _swig_property(_csnd.CsoundRandMTState_mt_get, _csnd.CsoundRandMTState_mt_set)
    def __init__(self): 
        """__init__(self) -> CsoundRandMTState"""
        this = _csnd.new_CsoundRandMTState()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundRandMTState
    __del__ = lambda self : None;
CsoundRandMTState_swigregister = _csnd.CsoundRandMTState_swigregister
CsoundRandMTState_swigregister(CsoundRandMTState)

class CsoundChannelListEntry(_object):
    """Proxy of C++ CsoundChannelListEntry class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CsoundChannelListEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CsoundChannelListEntry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _csnd.CsoundChannelListEntry_name_set
    __swig_getmethods__["name"] = _csnd.CsoundChannelListEntry_name_get
    if _newclass:name = _swig_property(_csnd.CsoundChannelListEntry_name_get, _csnd.CsoundChannelListEntry_name_set)
    __swig_setmethods__["type"] = _csnd.CsoundChannelListEntry_type_set
    __swig_getmethods__["type"] = _csnd.CsoundChannelListEntry_type_get
    if _newclass:type = _swig_property(_csnd.CsoundChannelListEntry_type_get, _csnd.CsoundChannelListEntry_type_set)
    def __init__(self): 
        """__init__(self) -> CsoundChannelListEntry"""
        this = _csnd.new_CsoundChannelListEntry()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundChannelListEntry
    __del__ = lambda self : None;
CsoundChannelListEntry_swigregister = _csnd.CsoundChannelListEntry_swigregister
CsoundChannelListEntry_swigregister(CsoundChannelListEntry)

class PVSDATEXT(_object):
    """Proxy of C++ PVSDATEXT 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"] = _csnd.PVSDATEXT_N_set
    __swig_getmethods__["N"] = _csnd.PVSDATEXT_N_get
    if _newclass:N = _swig_property(_csnd.PVSDATEXT_N_get, _csnd.PVSDATEXT_N_set)
    __swig_setmethods__["sliding"] = _csnd.PVSDATEXT_sliding_set
    __swig_getmethods__["sliding"] = _csnd.PVSDATEXT_sliding_get
    if _newclass:sliding = _swig_property(_csnd.PVSDATEXT_sliding_get, _csnd.PVSDATEXT_sliding_set)
    __swig_setmethods__["NB"] = _csnd.PVSDATEXT_NB_set
    __swig_getmethods__["NB"] = _csnd.PVSDATEXT_NB_get
    if _newclass:NB = _swig_property(_csnd.PVSDATEXT_NB_get, _csnd.PVSDATEXT_NB_set)
    __swig_setmethods__["overlap"] = _csnd.PVSDATEXT_overlap_set
    __swig_getmethods__["overlap"] = _csnd.PVSDATEXT_overlap_get
    if _newclass:overlap = _swig_property(_csnd.PVSDATEXT_overlap_get, _csnd.PVSDATEXT_overlap_set)
    __swig_setmethods__["winsize"] = _csnd.PVSDATEXT_winsize_set
    __swig_getmethods__["winsize"] = _csnd.PVSDATEXT_winsize_get
    if _newclass:winsize = _swig_property(_csnd.PVSDATEXT_winsize_get, _csnd.PVSDATEXT_winsize_set)
    __swig_setmethods__["wintype"] = _csnd.PVSDATEXT_wintype_set
    __swig_getmethods__["wintype"] = _csnd.PVSDATEXT_wintype_get
    if _newclass:wintype = _swig_property(_csnd.PVSDATEXT_wintype_get, _csnd.PVSDATEXT_wintype_set)
    __swig_setmethods__["format"] = _csnd.PVSDATEXT_format_set
    __swig_getmethods__["format"] = _csnd.PVSDATEXT_format_get
    if _newclass:format = _swig_property(_csnd.PVSDATEXT_format_get, _csnd.PVSDATEXT_format_set)
    __swig_setmethods__["framecount"] = _csnd.PVSDATEXT_framecount_set
    __swig_getmethods__["framecount"] = _csnd.PVSDATEXT_framecount_get
    if _newclass:framecount = _swig_property(_csnd.PVSDATEXT_framecount_get, _csnd.PVSDATEXT_framecount_set)
    __swig_setmethods__["frame"] = _csnd.PVSDATEXT_frame_set
    __swig_getmethods__["frame"] = _csnd.PVSDATEXT_frame_get
    if _newclass:frame = _swig_property(_csnd.PVSDATEXT_frame_get, _csnd.PVSDATEXT_frame_set)
    def __init__(self): 
        """__init__(self) -> PVSDATEXT"""
        this = _csnd.new_PVSDATEXT()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_PVSDATEXT
    __del__ = lambda self : None;
PVSDATEXT_swigregister = _csnd.PVSDATEXT_swigregister
PVSDATEXT_swigregister(PVSDATEXT)


def csoundInitialize(*args):
  """csoundInitialize(int argc, char argv, int flags) -> int"""
  return _csnd.csoundInitialize(*args)

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

def csoundPreCompile(*args):
  """csoundPreCompile(CSOUND arg0) -> int"""
  return _csnd.csoundPreCompile(*args)

def csoundInitializeCscore(*args):
  """csoundInitializeCscore(CSOUND arg0, FILE insco, FILE outsco) -> int"""
  return _csnd.csoundInitializeCscore(*args)

def csoundQueryInterface(*args):
  """csoundQueryInterface(char name, void iface, int version) -> int"""
  return _csnd.csoundQueryInterface(*args)

def csoundDestroy(*args):
  """csoundDestroy(CSOUND arg0)"""
  return _csnd.csoundDestroy(*args)

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

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

def csoundGetHostData(*args):
  """csoundGetHostData(CSOUND arg0) -> void"""
  return _csnd.csoundGetHostData(*args)

def csoundSetHostData(*args):
  """csoundSetHostData(CSOUND arg0, void hostData)"""
  return _csnd.csoundSetHostData(*args)

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

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

def csoundCompile(*args):
  """csoundCompile(CSOUND arg0, int argc, char argv) -> int"""
  return _csnd.csoundCompile(*args)

def csoundPerform(*args):
  """csoundPerform(CSOUND arg0) -> int"""
  return _csnd.csoundPerform(*args)

def csoundPerformKsmps(*args):
  """csoundPerformKsmps(CSOUND arg0) -> int"""
  return _csnd.csoundPerformKsmps(*args)

def csoundPerformKsmpsAbsolute(*args):
  """csoundPerformKsmpsAbsolute(CSOUND arg0) -> int"""
  return _csnd.csoundPerformKsmpsAbsolute(*args)

def csoundPerformBuffer(*args):
  """csoundPerformBuffer(CSOUND arg0) -> int"""
  return _csnd.csoundPerformBuffer(*args)

def csoundStop(*args):
  """csoundStop(CSOUND arg0)"""
  return _csnd.csoundStop(*args)

def csoundCleanup(*args):
  """csoundCleanup(CSOUND arg0) -> int"""
  return _csnd.csoundCleanup(*args)

def csoundReset(*args):
  """csoundReset(CSOUND arg0)"""
  return _csnd.csoundReset(*args)

def csoundGetSr(*args):
  """csoundGetSr(CSOUND arg0) -> float"""
  return _csnd.csoundGetSr(*args)

def csoundGetKr(*args):
  """csoundGetKr(CSOUND arg0) -> float"""
  return _csnd.csoundGetKr(*args)

def csoundGetKsmps(*args):
  """csoundGetKsmps(CSOUND arg0) -> int"""
  return _csnd.csoundGetKsmps(*args)

def csoundGetNchnls(*args):
  """csoundGetNchnls(CSOUND arg0) -> int"""
  return _csnd.csoundGetNchnls(*args)

def csoundGet0dBFS(*args):
  """csoundGet0dBFS(CSOUND arg0) -> float"""
  return _csnd.csoundGet0dBFS(*args)

def csoundGetStrVarMaxLen(*args):
  """csoundGetStrVarMaxLen(CSOUND arg0) -> int"""
  return _csnd.csoundGetStrVarMaxLen(*args)

def csoundGetSampleFormat(*args):
  """csoundGetSampleFormat(CSOUND arg0) -> int"""
  return _csnd.csoundGetSampleFormat(*args)

def csoundGetSampleSize(*args):
  """csoundGetSampleSize(CSOUND arg0) -> int"""
  return _csnd.csoundGetSampleSize(*args)

def csoundGetInputBufferSize(*args):
  """csoundGetInputBufferSize(CSOUND arg0) -> long"""
  return _csnd.csoundGetInputBufferSize(*args)

def csoundGetOutputBufferSize(*args):
  """csoundGetOutputBufferSize(CSOUND arg0) -> long"""
  return _csnd.csoundGetOutputBufferSize(*args)

def csoundGetInputBuffer(*args):
  """csoundGetInputBuffer(CSOUND arg0) -> float"""
  return _csnd.csoundGetInputBuffer(*args)

def csoundGetOutputBuffer(*args):
  """csoundGetOutputBuffer(CSOUND arg0) -> float"""
  return _csnd.csoundGetOutputBuffer(*args)

def csoundGetSpin(*args):
  """csoundGetSpin(CSOUND arg0) -> float"""
  return _csnd.csoundGetSpin(*args)

def csoundGetSpout(*args):
  """csoundGetSpout(CSOUND arg0) -> float"""
  return _csnd.csoundGetSpout(*args)

def csoundGetOutputFileName(*args):
  """csoundGetOutputFileName(CSOUND arg0) -> char"""
  return _csnd.csoundGetOutputFileName(*args)

def csoundSetHostImplementedAudioIO(*args):
  """csoundSetHostImplementedAudioIO(CSOUND arg0, int state, int bufSize)"""
  return _csnd.csoundSetHostImplementedAudioIO(*args)

def csoundGetScoreTime(*args):
  """csoundGetScoreTime(CSOUND arg0) -> double"""
  return _csnd.csoundGetScoreTime(*args)

def csoundIsScorePending(*args):
  """csoundIsScorePending(CSOUND arg0) -> int"""
  return _csnd.csoundIsScorePending(*args)

def csoundSetScorePending(*args):
  """csoundSetScorePending(CSOUND arg0, int pending)"""
  return _csnd.csoundSetScorePending(*args)

def csoundGetScoreOffsetSeconds(*args):
  """csoundGetScoreOffsetSeconds(CSOUND arg0) -> float"""
  return _csnd.csoundGetScoreOffsetSeconds(*args)

def csoundSetScoreOffsetSeconds(*args):
  """csoundSetScoreOffsetSeconds(CSOUND arg0, float time)"""
  return _csnd.csoundSetScoreOffsetSeconds(*args)

def csoundRewindScore(*args):
  """csoundRewindScore(CSOUND arg0)"""
  return _csnd.csoundRewindScore(*args)

def csoundScoreSort(*args):
  """csoundScoreSort(CSOUND arg0, FILE inFile, FILE outFile) -> int"""
  return _csnd.csoundScoreSort(*args)

def csoundScoreExtract(*args):
  """csoundScoreExtract(CSOUND arg0, FILE inFile, FILE outFile, FILE extractFile) -> int"""
  return _csnd.csoundScoreExtract(*args)

def csoundMessage(*args):
  """csoundMessage(CSOUND arg0, char format, v(...) *args)"""
  return _csnd.csoundMessage(*args)

def csoundMessageS(*args):
  """csoundMessageS(CSOUND arg0, int attr, char format, v(...) *args)"""
  return _csnd.csoundMessageS(*args)

def csoundGetMessageLevel(*args):
  """csoundGetMessageLevel(CSOUND arg0) -> int"""
  return _csnd.csoundGetMessageLevel(*args)

def csoundSetMessageLevel(*args):
  """csoundSetMessageLevel(CSOUND arg0, int messageLevel)"""
  return _csnd.csoundSetMessageLevel(*args)

def csoundInputMessage(*args):
  """csoundInputMessage(CSOUND arg0, char message)"""
  return _csnd.csoundInputMessage(*args)

def csoundKeyPress(*args):
  """csoundKeyPress(CSOUND arg0, char c)"""
  return _csnd.csoundKeyPress(*args)

def csoundScoreEvent(*args):
  """csoundScoreEvent(CSOUND arg0, char type, float pFields, long numFields) -> int"""
  return _csnd.csoundScoreEvent(*args)

def csoundNewOpcodeList(*args):
  """csoundNewOpcodeList(CSOUND arg0, opcodeListEntry opcodelist) -> int"""
  return _csnd.csoundNewOpcodeList(*args)

def csoundDisposeOpcodeList(*args):
  """csoundDisposeOpcodeList(CSOUND arg0, opcodeListEntry opcodelist)"""
  return _csnd.csoundDisposeOpcodeList(*args)

def csoundAppendOpcode(*args):
  """
    csoundAppendOpcode(CSOUND arg0, char opname, int dsblksiz, int thread, 
        char outypes, char intypes, int iopadr, int kopadr, 
        int aopadr) -> int
    """
  return _csnd.csoundAppendOpcode(*args)

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

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

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

def csoundGetDebug(*args):
  """csoundGetDebug(CSOUND arg0) -> int"""
  return _csnd.csoundGetDebug(*args)

def csoundSetDebug(*args):
  """csoundSetDebug(CSOUND arg0, int debug)"""
  return _csnd.csoundSetDebug(*args)

def csoundTableLength(*args):
  """csoundTableLength(CSOUND arg0, int table) -> int"""
  return _csnd.csoundTableLength(*args)

def csoundTableGet(*args):
  """csoundTableGet(CSOUND arg0, int table, int index) -> float"""
  return _csnd.csoundTableGet(*args)

def csoundTableSet(*args):
  """csoundTableSet(CSOUND arg0, int table, int index, float value)"""
  return _csnd.csoundTableSet(*args)

def csoundGetTable(*args):
  """csoundGetTable(CSOUND arg0, float tablePtr, int tableNum) -> int"""
  return _csnd.csoundGetTable(*args)

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

def csoundGetCurrentThreadId():
  """csoundGetCurrentThreadId() -> void"""
  return _csnd.csoundGetCurrentThreadId()

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

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

def csoundCreateThreadLock():
  """csoundCreateThreadLock() -> void"""
  return _csnd.csoundCreateThreadLock()

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

def csoundWaitThreadLockNoTimeout(*args):
  """csoundWaitThreadLockNoTimeout(void lock)"""
  return _csnd.csoundWaitThreadLockNoTimeout(*args)

def csoundNotifyThreadLock(*args):
  """csoundNotifyThreadLock(void lock)"""
  return _csnd.csoundNotifyThreadLock(*args)

def csoundDestroyThreadLock(*args):
  """csoundDestroyThreadLock(void lock)"""
  return _csnd.csoundDestroyThreadLock(*args)

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

def csoundLockMutex(*args):
  """csoundLockMutex(void mutex_)"""
  return _csnd.csoundLockMutex(*args)

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

def csoundUnlockMutex(*args):
  """csoundUnlockMutex(void mutex_)"""
  return _csnd.csoundUnlockMutex(*args)

def csoundDestroyMutex(*args):
  """csoundDestroyMutex(void mutex_)"""
  return _csnd.csoundDestroyMutex(*args)

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

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

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

def csoundSleep(*args):
  """csoundSleep(size_t milliseconds)"""
  return _csnd.csoundSleep(*args)

def csoundInitTimerStruct(*args):
  """csoundInitTimerStruct( arg0)"""
  return _csnd.csoundInitTimerStruct(*args)

def csoundGetRealTime(*args):
  """csoundGetRealTime( arg0) -> double"""
  return _csnd.csoundGetRealTime(*args)

def csoundGetCPUTime(*args):
  """csoundGetCPUTime( arg0) -> double"""
  return _csnd.csoundGetCPUTime(*args)

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

def csoundSetLanguage(*args):
  """csoundSetLanguage(cslanguage_t lang_code)"""
  return _csnd.csoundSetLanguage(*args)

def csoundLocalizeString(*args):
  """csoundLocalizeString(char s) -> char"""
  return _csnd.csoundLocalizeString(*args)

def csoundCreateGlobalVariable(*args):
  """csoundCreateGlobalVariable(CSOUND arg0, char name, size_t nbytes) -> int"""
  return _csnd.csoundCreateGlobalVariable(*args)

def csoundQueryGlobalVariable(*args):
  """csoundQueryGlobalVariable(CSOUND arg0, char name) -> void"""
  return _csnd.csoundQueryGlobalVariable(*args)

def csoundQueryGlobalVariableNoCheck(*args):
  """csoundQueryGlobalVariableNoCheck(CSOUND arg0, char name) -> void"""
  return _csnd.csoundQueryGlobalVariableNoCheck(*args)

def csoundDestroyGlobalVariable(*args):
  """csoundDestroyGlobalVariable(CSOUND arg0, char name) -> int"""
  return _csnd.csoundDestroyGlobalVariable(*args)

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

def csoundGetRtRecordUserData(*args):
  """csoundGetRtRecordUserData(CSOUND arg0) -> void"""
  return _csnd.csoundGetRtRecordUserData(*args)

def csoundGetRtPlayUserData(*args):
  """csoundGetRtPlayUserData(CSOUND arg0) -> void"""
  return _csnd.csoundGetRtPlayUserData(*args)

def csoundRunUtility(*args):
  """csoundRunUtility(CSOUND arg0, char name, int argc, char argv) -> int"""
  return _csnd.csoundRunUtility(*args)

def csoundListUtilities(*args):
  """csoundListUtilities(CSOUND arg0) -> char"""
  return _csnd.csoundListUtilities(*args)

def csoundDeleteUtilityList(*args):
  """csoundDeleteUtilityList(CSOUND arg0, char lst)"""
  return _csnd.csoundDeleteUtilityList(*args)

def csoundGetUtilityDescription(*args):
  """csoundGetUtilityDescription(CSOUND arg0, char utilName) -> char"""
  return _csnd.csoundGetUtilityDescription(*args)

def csoundGetChannelPtr(*args):
  """csoundGetChannelPtr(CSOUND arg0, float p, char name, int type) -> int"""
  return _csnd.csoundGetChannelPtr(*args)

def csoundListChannels(*args):
  """csoundListChannels(CSOUND arg0,  lst) -> int"""
  return _csnd.csoundListChannels(*args)

def csoundDeleteChannelList(*args):
  """csoundDeleteChannelList(CSOUND arg0,  lst)"""
  return _csnd.csoundDeleteChannelList(*args)

def csoundSetControlChannelParams(*args):
  """
    csoundSetControlChannelParams(CSOUND arg0, char name, int type, float dflt, float min, 
        float max) -> int
    """
  return _csnd.csoundSetControlChannelParams(*args)

def csoundGetControlChannelParams(*args):
  """csoundGetControlChannelParams(CSOUND arg0, char name, float dflt, float min, float max) -> int"""
  return _csnd.csoundGetControlChannelParams(*args)

def csoundSetChannelIOCallback(*args):
  """csoundSetChannelIOCallback(CSOUND arg0, CsoundChannelIOCallback_t func)"""
  return _csnd.csoundSetChannelIOCallback(*args)

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

def csoundSeedRandMT(*args):
  """csoundSeedRandMT( p, uint32_t initKey, uint32_t keyLength)"""
  return _csnd.csoundSeedRandMT(*args)

def csoundRandMT(*args):
  """csoundRandMT( p) -> uint32_t"""
  return _csnd.csoundRandMT(*args)

def csoundChanIKSet(*args):
  """csoundChanIKSet(CSOUND arg0, float value, int n) -> int"""
  return _csnd.csoundChanIKSet(*args)

def csoundChanOKGet(*args):
  """csoundChanOKGet(CSOUND arg0, float value, int n) -> int"""
  return _csnd.csoundChanOKGet(*args)

def csoundChanIASet(*args):
  """csoundChanIASet(CSOUND arg0, float value, int n) -> int"""
  return _csnd.csoundChanIASet(*args)

def csoundChanOAGet(*args):
  """csoundChanOAGet(CSOUND arg0, float value, int n) -> int"""
  return _csnd.csoundChanOAGet(*args)

def csoundPvsinSet(*args):
  """csoundPvsinSet(CSOUND arg0,  fin, int n) -> int"""
  return _csnd.csoundPvsinSet(*args)

def csoundPvsoutGet(*args):
  """csoundPvsoutGet(CSOUND csound,  fout, int n) -> int"""
  return _csnd.csoundPvsoutGet(*args)

def csoundSetCallback(*args):
  """csoundSetCallback(CSOUND arg0, int func, void userData, unsigned int typeMask) -> int"""
  return _csnd.csoundSetCallback(*args)

def csoundRemoveCallback(*args):
  """csoundRemoveCallback(CSOUND arg0, int func)"""
  return _csnd.csoundRemoveCallback(*args)

def csoundEnableMessageBuffer(*args):
  """csoundEnableMessageBuffer(CSOUND csound, int toStdOut)"""
  return _csnd.csoundEnableMessageBuffer(*args)

def csoundGetFirstMessage(*args):
  """csoundGetFirstMessage(CSOUND csound) -> char"""
  return _csnd.csoundGetFirstMessage(*args)

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

def csoundPopFirstMessage(*args):
  """csoundPopFirstMessage(CSOUND csound)"""
  return _csnd.csoundPopFirstMessage(*args)

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

def csoundDestroyMessageBuffer(*args):
  """csoundDestroyMessageBuffer(CSOUND csound)"""
  return _csnd.csoundDestroyMessageBuffer(*args)

def sigcpy(*args):
  """sigcpy(float dest, float src, int size)"""
  return _csnd.sigcpy(*args)
class csCfgVariableHead_t(_object):
    """Proxy of C++ csCfgVariableHead_t 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"] = _csnd.csCfgVariableHead_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableHead_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableHead_t_nxt_get, _csnd.csCfgVariableHead_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableHead_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableHead_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableHead_t_name_get, _csnd.csCfgVariableHead_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableHead_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableHead_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableHead_t_p_get, _csnd.csCfgVariableHead_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableHead_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableHead_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableHead_t_type_get, _csnd.csCfgVariableHead_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableHead_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableHead_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableHead_t_flags_get, _csnd.csCfgVariableHead_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableHead_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableHead_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableHead_t_shortDesc_get, _csnd.csCfgVariableHead_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableHead_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableHead_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableHead_t_longDesc_get, _csnd.csCfgVariableHead_t_longDesc_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableHead_t"""
        this = _csnd.new_csCfgVariableHead_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableHead_t
    __del__ = lambda self : None;
csCfgVariableHead_t_swigregister = _csnd.csCfgVariableHead_t_swigregister
csCfgVariableHead_t_swigregister(csCfgVariableHead_t)

class csCfgVariableInt_t(_object):
    """Proxy of C++ csCfgVariableInt_t 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"] = _csnd.csCfgVariableInt_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableInt_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableInt_t_nxt_get, _csnd.csCfgVariableInt_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableInt_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableInt_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableInt_t_name_get, _csnd.csCfgVariableInt_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableInt_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableInt_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableInt_t_p_get, _csnd.csCfgVariableInt_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableInt_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableInt_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableInt_t_type_get, _csnd.csCfgVariableInt_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableInt_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableInt_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableInt_t_flags_get, _csnd.csCfgVariableInt_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableInt_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableInt_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableInt_t_shortDesc_get, _csnd.csCfgVariableInt_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableInt_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableInt_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableInt_t_longDesc_get, _csnd.csCfgVariableInt_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd.csCfgVariableInt_t_min_set
    __swig_getmethods__["min"] = _csnd.csCfgVariableInt_t_min_get
    if _newclass:min = _swig_property(_csnd.csCfgVariableInt_t_min_get, _csnd.csCfgVariableInt_t_min_set)
    __swig_setmethods__["max"] = _csnd.csCfgVariableInt_t_max_set
    __swig_getmethods__["max"] = _csnd.csCfgVariableInt_t_max_get
    if _newclass:max = _swig_property(_csnd.csCfgVariableInt_t_max_get, _csnd.csCfgVariableInt_t_max_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableInt_t"""
        this = _csnd.new_csCfgVariableInt_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableInt_t
    __del__ = lambda self : None;
csCfgVariableInt_t_swigregister = _csnd.csCfgVariableInt_t_swigregister
csCfgVariableInt_t_swigregister(csCfgVariableInt_t)

class csCfgVariableBoolean_t(_object):
    """Proxy of C++ csCfgVariableBoolean_t 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"] = _csnd.csCfgVariableBoolean_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableBoolean_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableBoolean_t_nxt_get, _csnd.csCfgVariableBoolean_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableBoolean_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableBoolean_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableBoolean_t_name_get, _csnd.csCfgVariableBoolean_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableBoolean_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableBoolean_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableBoolean_t_p_get, _csnd.csCfgVariableBoolean_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableBoolean_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableBoolean_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableBoolean_t_type_get, _csnd.csCfgVariableBoolean_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableBoolean_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableBoolean_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableBoolean_t_flags_get, _csnd.csCfgVariableBoolean_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableBoolean_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableBoolean_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableBoolean_t_shortDesc_get, _csnd.csCfgVariableBoolean_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableBoolean_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableBoolean_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableBoolean_t_longDesc_get, _csnd.csCfgVariableBoolean_t_longDesc_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableBoolean_t"""
        this = _csnd.new_csCfgVariableBoolean_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableBoolean_t
    __del__ = lambda self : None;
csCfgVariableBoolean_t_swigregister = _csnd.csCfgVariableBoolean_t_swigregister
csCfgVariableBoolean_t_swigregister(csCfgVariableBoolean_t)

class csCfgVariableFloat_t(_object):
    """Proxy of C++ csCfgVariableFloat_t 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"] = _csnd.csCfgVariableFloat_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableFloat_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableFloat_t_nxt_get, _csnd.csCfgVariableFloat_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableFloat_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableFloat_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableFloat_t_name_get, _csnd.csCfgVariableFloat_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableFloat_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableFloat_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableFloat_t_p_get, _csnd.csCfgVariableFloat_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableFloat_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableFloat_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableFloat_t_type_get, _csnd.csCfgVariableFloat_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableFloat_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableFloat_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableFloat_t_flags_get, _csnd.csCfgVariableFloat_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableFloat_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableFloat_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableFloat_t_shortDesc_get, _csnd.csCfgVariableFloat_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableFloat_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableFloat_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableFloat_t_longDesc_get, _csnd.csCfgVariableFloat_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd.csCfgVariableFloat_t_min_set
    __swig_getmethods__["min"] = _csnd.csCfgVariableFloat_t_min_get
    if _newclass:min = _swig_property(_csnd.csCfgVariableFloat_t_min_get, _csnd.csCfgVariableFloat_t_min_set)
    __swig_setmethods__["max"] = _csnd.csCfgVariableFloat_t_max_set
    __swig_getmethods__["max"] = _csnd.csCfgVariableFloat_t_max_get
    if _newclass:max = _swig_property(_csnd.csCfgVariableFloat_t_max_get, _csnd.csCfgVariableFloat_t_max_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableFloat_t"""
        this = _csnd.new_csCfgVariableFloat_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableFloat_t
    __del__ = lambda self : None;
csCfgVariableFloat_t_swigregister = _csnd.csCfgVariableFloat_t_swigregister
csCfgVariableFloat_t_swigregister(csCfgVariableFloat_t)

class csCfgVariableDouble_t(_object):
    """Proxy of C++ csCfgVariableDouble_t 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"] = _csnd.csCfgVariableDouble_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableDouble_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableDouble_t_nxt_get, _csnd.csCfgVariableDouble_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableDouble_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableDouble_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableDouble_t_name_get, _csnd.csCfgVariableDouble_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableDouble_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableDouble_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableDouble_t_p_get, _csnd.csCfgVariableDouble_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableDouble_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableDouble_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableDouble_t_type_get, _csnd.csCfgVariableDouble_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableDouble_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableDouble_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableDouble_t_flags_get, _csnd.csCfgVariableDouble_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableDouble_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableDouble_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableDouble_t_shortDesc_get, _csnd.csCfgVariableDouble_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableDouble_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableDouble_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableDouble_t_longDesc_get, _csnd.csCfgVariableDouble_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd.csCfgVariableDouble_t_min_set
    __swig_getmethods__["min"] = _csnd.csCfgVariableDouble_t_min_get
    if _newclass:min = _swig_property(_csnd.csCfgVariableDouble_t_min_get, _csnd.csCfgVariableDouble_t_min_set)
    __swig_setmethods__["max"] = _csnd.csCfgVariableDouble_t_max_set
    __swig_getmethods__["max"] = _csnd.csCfgVariableDouble_t_max_get
    if _newclass:max = _swig_property(_csnd.csCfgVariableDouble_t_max_get, _csnd.csCfgVariableDouble_t_max_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableDouble_t"""
        this = _csnd.new_csCfgVariableDouble_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableDouble_t
    __del__ = lambda self : None;
csCfgVariableDouble_t_swigregister = _csnd.csCfgVariableDouble_t_swigregister
csCfgVariableDouble_t_swigregister(csCfgVariableDouble_t)

class csCfgVariableMYFLT_t(_object):
    """Proxy of C++ csCfgVariableMYFLT_t 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"] = _csnd.csCfgVariableMYFLT_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableMYFLT_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableMYFLT_t_nxt_get, _csnd.csCfgVariableMYFLT_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableMYFLT_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableMYFLT_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableMYFLT_t_name_get, _csnd.csCfgVariableMYFLT_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableMYFLT_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableMYFLT_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableMYFLT_t_p_get, _csnd.csCfgVariableMYFLT_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableMYFLT_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableMYFLT_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableMYFLT_t_type_get, _csnd.csCfgVariableMYFLT_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableMYFLT_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableMYFLT_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableMYFLT_t_flags_get, _csnd.csCfgVariableMYFLT_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableMYFLT_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableMYFLT_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableMYFLT_t_shortDesc_get, _csnd.csCfgVariableMYFLT_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableMYFLT_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableMYFLT_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableMYFLT_t_longDesc_get, _csnd.csCfgVariableMYFLT_t_longDesc_set)
    __swig_setmethods__["min"] = _csnd.csCfgVariableMYFLT_t_min_set
    __swig_getmethods__["min"] = _csnd.csCfgVariableMYFLT_t_min_get
    if _newclass:min = _swig_property(_csnd.csCfgVariableMYFLT_t_min_get, _csnd.csCfgVariableMYFLT_t_min_set)
    __swig_setmethods__["max"] = _csnd.csCfgVariableMYFLT_t_max_set
    __swig_getmethods__["max"] = _csnd.csCfgVariableMYFLT_t_max_get
    if _newclass:max = _swig_property(_csnd.csCfgVariableMYFLT_t_max_get, _csnd.csCfgVariableMYFLT_t_max_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableMYFLT_t"""
        this = _csnd.new_csCfgVariableMYFLT_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableMYFLT_t
    __del__ = lambda self : None;
csCfgVariableMYFLT_t_swigregister = _csnd.csCfgVariableMYFLT_t_swigregister
csCfgVariableMYFLT_t_swigregister(csCfgVariableMYFLT_t)

class csCfgVariableString_t(_object):
    """Proxy of C++ csCfgVariableString_t 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"] = _csnd.csCfgVariableString_t_nxt_set
    __swig_getmethods__["nxt"] = _csnd.csCfgVariableString_t_nxt_get
    if _newclass:nxt = _swig_property(_csnd.csCfgVariableString_t_nxt_get, _csnd.csCfgVariableString_t_nxt_set)
    __swig_setmethods__["name"] = _csnd.csCfgVariableString_t_name_set
    __swig_getmethods__["name"] = _csnd.csCfgVariableString_t_name_get
    if _newclass:name = _swig_property(_csnd.csCfgVariableString_t_name_get, _csnd.csCfgVariableString_t_name_set)
    __swig_setmethods__["p"] = _csnd.csCfgVariableString_t_p_set
    __swig_getmethods__["p"] = _csnd.csCfgVariableString_t_p_get
    if _newclass:p = _swig_property(_csnd.csCfgVariableString_t_p_get, _csnd.csCfgVariableString_t_p_set)
    __swig_setmethods__["type"] = _csnd.csCfgVariableString_t_type_set
    __swig_getmethods__["type"] = _csnd.csCfgVariableString_t_type_get
    if _newclass:type = _swig_property(_csnd.csCfgVariableString_t_type_get, _csnd.csCfgVariableString_t_type_set)
    __swig_setmethods__["flags"] = _csnd.csCfgVariableString_t_flags_set
    __swig_getmethods__["flags"] = _csnd.csCfgVariableString_t_flags_get
    if _newclass:flags = _swig_property(_csnd.csCfgVariableString_t_flags_get, _csnd.csCfgVariableString_t_flags_set)
    __swig_setmethods__["shortDesc"] = _csnd.csCfgVariableString_t_shortDesc_set
    __swig_getmethods__["shortDesc"] = _csnd.csCfgVariableString_t_shortDesc_get
    if _newclass:shortDesc = _swig_property(_csnd.csCfgVariableString_t_shortDesc_get, _csnd.csCfgVariableString_t_shortDesc_set)
    __swig_setmethods__["longDesc"] = _csnd.csCfgVariableString_t_longDesc_set
    __swig_getmethods__["longDesc"] = _csnd.csCfgVariableString_t_longDesc_get
    if _newclass:longDesc = _swig_property(_csnd.csCfgVariableString_t_longDesc_get, _csnd.csCfgVariableString_t_longDesc_set)
    __swig_setmethods__["maxlen"] = _csnd.csCfgVariableString_t_maxlen_set
    __swig_getmethods__["maxlen"] = _csnd.csCfgVariableString_t_maxlen_get
    if _newclass:maxlen = _swig_property(_csnd.csCfgVariableString_t_maxlen_get, _csnd.csCfgVariableString_t_maxlen_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariableString_t"""
        this = _csnd.new_csCfgVariableString_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariableString_t
    __del__ = lambda self : None;
csCfgVariableString_t_swigregister = _csnd.csCfgVariableString_t_swigregister
csCfgVariableString_t_swigregister(csCfgVariableString_t)

class csCfgVariable_t(_object):
    """Proxy of C++ csCfgVariable_t 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"] = _csnd.csCfgVariable_t_h_set
    __swig_getmethods__["h"] = _csnd.csCfgVariable_t_h_get
    if _newclass:h = _swig_property(_csnd.csCfgVariable_t_h_get, _csnd.csCfgVariable_t_h_set)
    __swig_setmethods__["i"] = _csnd.csCfgVariable_t_i_set
    __swig_getmethods__["i"] = _csnd.csCfgVariable_t_i_get
    if _newclass:i = _swig_property(_csnd.csCfgVariable_t_i_get, _csnd.csCfgVariable_t_i_set)
    __swig_setmethods__["b"] = _csnd.csCfgVariable_t_b_set
    __swig_getmethods__["b"] = _csnd.csCfgVariable_t_b_get
    if _newclass:b = _swig_property(_csnd.csCfgVariable_t_b_get, _csnd.csCfgVariable_t_b_set)
    __swig_setmethods__["f"] = _csnd.csCfgVariable_t_f_set
    __swig_getmethods__["f"] = _csnd.csCfgVariable_t_f_get
    if _newclass:f = _swig_property(_csnd.csCfgVariable_t_f_get, _csnd.csCfgVariable_t_f_set)
    __swig_setmethods__["d"] = _csnd.csCfgVariable_t_d_set
    __swig_getmethods__["d"] = _csnd.csCfgVariable_t_d_get
    if _newclass:d = _swig_property(_csnd.csCfgVariable_t_d_get, _csnd.csCfgVariable_t_d_set)
    __swig_setmethods__["m"] = _csnd.csCfgVariable_t_m_set
    __swig_getmethods__["m"] = _csnd.csCfgVariable_t_m_get
    if _newclass:m = _swig_property(_csnd.csCfgVariable_t_m_get, _csnd.csCfgVariable_t_m_set)
    __swig_setmethods__["s"] = _csnd.csCfgVariable_t_s_set
    __swig_getmethods__["s"] = _csnd.csCfgVariable_t_s_get
    if _newclass:s = _swig_property(_csnd.csCfgVariable_t_s_get, _csnd.csCfgVariable_t_s_set)
    def __init__(self): 
        """__init__(self) -> csCfgVariable_t"""
        this = _csnd.new_csCfgVariable_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_csCfgVariable_t
    __del__ = lambda self : None;
csCfgVariable_t_swigregister = _csnd.csCfgVariable_t_swigregister
csCfgVariable_t_swigregister(csCfgVariable_t)

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

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

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

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

def csoundQueryConfigurationVariable(*args):
  """csoundQueryConfigurationVariable(CSOUND csound, char name)"""
  return _csnd.csoundQueryConfigurationVariable(*args)

def csoundListConfigurationVariables(*args):
  """csoundListConfigurationVariables(CSOUND csound)"""
  return _csnd.csoundListConfigurationVariables(*args)

def csoundDeleteCfgVarList(*args):
  """csoundDeleteCfgVarList( lst)"""
  return _csnd.csoundDeleteCfgVarList(*args)

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

def csoundCfgErrorCodeToString(*args):
  """csoundCfgErrorCodeToString(int errcode) -> char"""
  return _csnd.csoundCfgErrorCodeToString(*args)
CSOUNDMSG_DEFAULT = _csnd.CSOUNDMSG_DEFAULT
CSOUNDMSG_ERROR = _csnd.CSOUNDMSG_ERROR
CSOUNDMSG_ORCH = _csnd.CSOUNDMSG_ORCH
CSOUNDMSG_REALTIME = _csnd.CSOUNDMSG_REALTIME
CSOUNDMSG_WARNING = _csnd.CSOUNDMSG_WARNING
CSOUNDMSG_FG_BLACK = _csnd.CSOUNDMSG_FG_BLACK
CSOUNDMSG_FG_RED = _csnd.CSOUNDMSG_FG_RED
CSOUNDMSG_FG_GREEN = _csnd.CSOUNDMSG_FG_GREEN
CSOUNDMSG_FG_YELLOW = _csnd.CSOUNDMSG_FG_YELLOW
CSOUNDMSG_FG_BLUE = _csnd.CSOUNDMSG_FG_BLUE
CSOUNDMSG_FG_MAGENTA = _csnd.CSOUNDMSG_FG_MAGENTA
CSOUNDMSG_FG_CYAN = _csnd.CSOUNDMSG_FG_CYAN
CSOUNDMSG_FG_WHITE = _csnd.CSOUNDMSG_FG_WHITE
CSOUNDMSG_FG_BOLD = _csnd.CSOUNDMSG_FG_BOLD
CSOUNDMSG_FG_UNDERLINE = _csnd.CSOUNDMSG_FG_UNDERLINE
CSOUNDMSG_BG_BLACK = _csnd.CSOUNDMSG_BG_BLACK
CSOUNDMSG_BG_RED = _csnd.CSOUNDMSG_BG_RED
CSOUNDMSG_BG_GREEN = _csnd.CSOUNDMSG_BG_GREEN
CSOUNDMSG_BG_ORANGE = _csnd.CSOUNDMSG_BG_ORANGE
CSOUNDMSG_BG_BLUE = _csnd.CSOUNDMSG_BG_BLUE
CSOUNDMSG_BG_MAGENTA = _csnd.CSOUNDMSG_BG_MAGENTA
CSOUNDMSG_BG_CYAN = _csnd.CSOUNDMSG_BG_CYAN
CSOUNDMSG_BG_GREY = _csnd.CSOUNDMSG_BG_GREY
CSOUNDMSG_TYPE_MASK = _csnd.CSOUNDMSG_TYPE_MASK
CSOUNDMSG_FG_COLOR_MASK = _csnd.CSOUNDMSG_FG_COLOR_MASK
CSOUNDMSG_FG_ATTR_MASK = _csnd.CSOUNDMSG_FG_ATTR_MASK
CSOUNDMSG_BG_COLOR_MASK = _csnd.CSOUNDMSG_BG_COLOR_MASK
CS_PACKAGE_NAME = _csnd.CS_PACKAGE_NAME
CS_PACKAGE_STRING = _csnd.CS_PACKAGE_STRING
CS_PACKAGE_TARNAME = _csnd.CS_PACKAGE_TARNAME
CS_PACKAGE_VERSION = _csnd.CS_PACKAGE_VERSION
CS_VERSION = _csnd.CS_VERSION
CS_SUBVER = _csnd.CS_SUBVER
CS_PATCHLEVEL = _csnd.CS_PATCHLEVEL
CS_APIVERSION = _csnd.CS_APIVERSION
CS_APISUBVER = _csnd.CS_APISUBVER
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
    def GetCsound(self):
        """GetCsound(self) -> CSOUND"""
        return _csnd.Csound_GetCsound(self)

    def PreCompile(self):
        """PreCompile(self) -> int"""
        return _csnd.Csound_PreCompile(self)

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

    def GetHostData(self):
        """GetHostData(self) -> void"""
        return _csnd.Csound_GetHostData(self)

    def SetHostData(self, *args):
        """SetHostData(self, void hostData)"""
        return _csnd.Csound_SetHostData(self, *args)

    def GetEnv(self, *args):
        """GetEnv(self, char name) -> char"""
        return _csnd.Csound_GetEnv(self, *args)

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

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

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

    def PerformKsmpsAbsolute(self):
        """PerformKsmpsAbsolute(self) -> int"""
        return _csnd.Csound_PerformKsmpsAbsolute(self)

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

    def Stop(self):
        """Stop(self)"""
        return _csnd.Csound_Stop(self)

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

    def Reset(self):
        """Reset(self)"""
        return _csnd.Csound_Reset(self)

    def GetSr(self):
        """GetSr(self) -> float"""
        return _csnd.Csound_GetSr(self)

    def GetKr(self):
        """GetKr(self) -> float"""
        return _csnd.Csound_GetKr(self)

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

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

    def Get0dBFS(self):
        """Get0dBFS(self) -> float"""
        return _csnd.Csound_Get0dBFS(self)

    def GetStrVarMaxLen(self):
        """GetStrVarMaxLen(self) -> int"""
        return _csnd.Csound_GetStrVarMaxLen(self)

    def GetSampleFormat(self):
        """GetSampleFormat(self) -> int"""
        return _csnd.Csound_GetSampleFormat(self)

    def GetSampleSize(self):
        """GetSampleSize(self) -> int"""
        return _csnd.Csound_GetSampleSize(self)

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

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

    def GetInputBuffer(self):
        """GetInputBuffer(self) -> float"""
        return _csnd.Csound_GetInputBuffer(self)

    def GetOutputBuffer(self):
        """GetOutputBuffer(self) -> float"""
        return _csnd.Csound_GetOutputBuffer(self)

    def GetSpin(self):
        """GetSpin(self) -> float"""
        return _csnd.Csound_GetSpin(self)

    def GetSpout(self):
        """GetSpout(self) -> float"""
        return _csnd.Csound_GetSpout(self)

    def GetOutputFileName(self):
        """GetOutputFileName(self) -> char"""
        return _csnd.Csound_GetOutputFileName(self)

    def SetHostImplementedAudioIO(self, *args):
        """SetHostImplementedAudioIO(self, int state, int bufSize)"""
        return _csnd.Csound_SetHostImplementedAudioIO(self, *args)

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

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

    def SetScorePending(self, *args):
        """SetScorePending(self, int pending)"""
        return _csnd.Csound_SetScorePending(self, *args)

    def GetScoreOffsetSeconds(self):
        """GetScoreOffsetSeconds(self) -> float"""
        return _csnd.Csound_GetScoreOffsetSeconds(self)

    def SetScoreOffsetSeconds(self, *args):
        """SetScoreOffsetSeconds(self, double time)"""
        return _csnd.Csound_SetScoreOffsetSeconds(self, *args)

    def RewindScore(self):
        """RewindScore(self)"""
        return _csnd.Csound_RewindScore(self)

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

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

    def Message(self, *args):
        """Message(self, char format, v(...) *args)"""
        return _csnd.Csound_Message(self, *args)

    def MessageS(self, *args):
        """MessageS(self, int attr, char format, v(...) *args)"""
        return _csnd.Csound_MessageS(self, *args)

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

    def SetMessageLevel(self, *args):
        """SetMessageLevel(self, int messageLevel)"""
        return _csnd.Csound_SetMessageLevel(self, *args)

    def InputMessage(self, *args):
        """InputMessage(self, char message)"""
        return _csnd.Csound_InputMessage(self, *args)

    def KeyPress(self, *args):
        """KeyPress(self, char c)"""
        return _csnd.Csound_KeyPress(self, *args)

    def ScoreEvent(self, *args):
        """ScoreEvent(self, char type, float pFields, long numFields) -> int"""
        return _csnd.Csound_ScoreEvent(self, *args)

    def NewOpcodeList(self, *args):
        """NewOpcodeList(self, opcodeListEntry opcodelist) -> int"""
        return _csnd.Csound_NewOpcodeList(self, *args)

    def DisposeOpcodeList(self, *args):
        """DisposeOpcodeList(self, opcodeListEntry opcodelist)"""
        return _csnd.Csound_DisposeOpcodeList(self, *args)

    def AppendOpcode(self, *args):
        """
        AppendOpcode(self, char opname, int dsblksiz, int thread, char outypes, 
            char intypes, int iopadr, int kopadr, int aopadr) -> int
        """
        return _csnd.Csound_AppendOpcode(self, *args)

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

    def SetDebug(self, *args):
        """SetDebug(self, int debug)"""
        return _csnd.Csound_SetDebug(self, *args)

    def TableLength(self, *args):
        """TableLength(self, int table) -> int"""
        return _csnd.Csound_TableLength(self, *args)

    def TableGet(self, *args):
        """TableGet(self, int table, int index) -> float"""
        return _csnd.Csound_TableGet(self, *args)

    def TableSet(self, *args):
        """TableSet(self, int table, int index, double value)"""
        return _csnd.Csound_TableSet(self, *args)

    def GetTable(self, *args):
        """GetTable(self, float tablePtr, int tableNum) -> int"""
        return _csnd.Csound_GetTable(self, *args)

    def CreateGlobalVariable(self, *args):
        """CreateGlobalVariable(self, char name, size_t nbytes) -> int"""
        return _csnd.Csound_CreateGlobalVariable(self, *args)

    def QueryGlobalVariable(self, *args):
        """QueryGlobalVariable(self, char name) -> void"""
        return _csnd.Csound_QueryGlobalVariable(self, *args)

    def QueryGlobalVariableNoCheck(self, *args):
        """QueryGlobalVariableNoCheck(self, char name) -> void"""
        return _csnd.Csound_QueryGlobalVariableNoCheck(self, *args)

    def DestroyGlobalVariable(self, *args):
        """DestroyGlobalVariable(self, char name) -> int"""
        return _csnd.Csound_DestroyGlobalVariable(self, *args)

    def GetRtRecordUserData(self):
        """GetRtRecordUserData(self) -> void"""
        return _csnd.Csound_GetRtRecordUserData(self)

    def GetRtPlayUserData(self):
        """GetRtPlayUserData(self) -> void"""
        return _csnd.Csound_GetRtPlayUserData(self)

    def RunUtility(self, *args):
        """RunUtility(self, char name, int argc, char argv) -> int"""
        return _csnd.Csound_RunUtility(self, *args)

    def ListUtilities(self):
        """ListUtilities(self) -> char"""
        return _csnd.Csound_ListUtilities(self)

    def DeleteUtilityList(self, *args):
        """DeleteUtilityList(self, char lst)"""
        return _csnd.Csound_DeleteUtilityList(self, *args)

    def GetUtilityDescription(self, *args):
        """GetUtilityDescription(self, char utilName) -> char"""
        return _csnd.Csound_GetUtilityDescription(self, *args)

    def GetChannelPtr(self, *args):
        """GetChannelPtr(self, float p, char name, int type) -> int"""
        return _csnd.Csound_GetChannelPtr(self, *args)

    def ListChannels(self, *args):
        """ListChannels(self,  lst) -> int"""
        return _csnd.Csound_ListChannels(self, *args)

    def DeleteChannelList(self, *args):
        """DeleteChannelList(self,  lst)"""
        return _csnd.Csound_DeleteChannelList(self, *args)

    def SetControlChannelParams(self, *args):
        """SetControlChannelParams(self, char name, int type, double dflt, double min, double max) -> int"""
        return _csnd.Csound_SetControlChannelParams(self, *args)

    def GetControlChannelParams(self, *args):
        """GetControlChannelParams(self, char name) -> int"""
        return _csnd.Csound_GetControlChannelParams(self, *args)

    def SetChannel(self, *args):
        """
        SetChannel(self, char name, double value)
        SetChannel(self, char name, char value)
        """
        return _csnd.Csound_SetChannel(self, *args)

    def GetChannel(self, *args):
        """GetChannel(self, char name) -> float"""
        return _csnd.Csound_GetChannel(self, *args)

    def ChanIKSet(self, *args):
        """ChanIKSet(self, double value, int n) -> int"""
        return _csnd.Csound_ChanIKSet(self, *args)

    def ChanOKGet(self, *args):
        """ChanOKGet(self, int n) -> int"""
        return _csnd.Csound_ChanOKGet(self, *args)

    def ChanIASet(self, *args):
        """ChanIASet(self, float value, int n) -> int"""
        return _csnd.Csound_ChanIASet(self, *args)

    def ChanOAGet(self, *args):
        """ChanOAGet(self, float value, int n) -> int"""
        return _csnd.Csound_ChanOAGet(self, *args)

    def PvsinSet(self, *args):
        """PvsinSet(self,  value, int n) -> int"""
        return _csnd.Csound_PvsinSet(self, *args)

    def PvsoutGet(self, *args):
        """PvsoutGet(self,  value, int n) -> int"""
        return _csnd.Csound_PvsoutGet(self, *args)

    def CreateConfigurationVariable(self, *args):
        """
        CreateConfigurationVariable(self, char name, void p, int type, int flags, void min, void max, 
            char shortDesc, char longDesc) -> int
        """
        return _csnd.Csound_CreateConfigurationVariable(self, *args)

    def SetConfigurationVariable(self, *args):
        """SetConfigurationVariable(self, char name, void value) -> int"""
        return _csnd.Csound_SetConfigurationVariable(self, *args)

    def ParseConfigurationVariable(self, *args):
        """ParseConfigurationVariable(self, char name, char value) -> int"""
        return _csnd.Csound_ParseConfigurationVariable(self, *args)

    def QueryConfigurationVariable(self, *args):
        """QueryConfigurationVariable(self, char name)"""
        return _csnd.Csound_QueryConfigurationVariable(self, *args)

    def ListConfigurationVariables(self):
        """ListConfigurationVariables(self)"""
        return _csnd.Csound_ListConfigurationVariables(self)

    def DeleteConfigurationVariable(self, *args):
        """DeleteConfigurationVariable(self, char name) -> int"""
        return _csnd.Csound_DeleteConfigurationVariable(self, *args)

    def SetChannelIOCallback(self, *args):
        """SetChannelIOCallback(self, CsoundChannelIOCallback_t func)"""
        return _csnd.Csound_SetChannelIOCallback(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> Csound
        __init__(self, void hostData) -> Csound
        """
        this = _csnd.new_Csound(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_Csound
    __del__ = lambda self : None;
    def EnableMessageBuffer(self, *args):
        """EnableMessageBuffer(self, int toStdOut)"""
        return _csnd.Csound_EnableMessageBuffer(self, *args)

    def GetFirstMessage(self):
        """GetFirstMessage(self) -> char"""
        return _csnd.Csound_GetFirstMessage(self)

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

    def PopFirstMessage(self):
        """PopFirstMessage(self)"""
        return _csnd.Csound_PopFirstMessage(self)

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

    def DestroyMessageBuffer(self):
        """DestroyMessageBuffer(self)"""
        return _csnd.Csound_DestroyMessageBuffer(self)

Csound_swigregister = _csnd.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(self, size_t milliseconds) -> int
        Lock(self)
        """
        return _csnd.CsoundThreadLock_Lock(self, *args)

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

    def Unlock(self):
        """Unlock(self)"""
        return _csnd.CsoundThreadLock_Unlock(self)

    def __init__(self, *args): 
        """
        __init__(self) -> CsoundThreadLock
        __init__(self, int locked) -> CsoundThreadLock
        """
        this = _csnd.new_CsoundThreadLock(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundThreadLock
    __del__ = lambda self : None;
CsoundThreadLock_swigregister = _csnd.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(self)"""
        return _csnd.CsoundMutex_Lock(self)

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

    def Unlock(self):
        """Unlock(self)"""
        return _csnd.CsoundMutex_Unlock(self)

    def __init__(self, *args): 
        """
        __init__(self) -> CsoundMutex
        __init__(self, int isRecursive) -> CsoundMutex
        """
        this = _csnd.new_CsoundMutex(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMutex
    __del__ = lambda self : None;
CsoundMutex_swigregister = _csnd.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(self) -> uint32_t"""
        return _csnd.CsoundRandMT_Random(self)

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

    def __init__(self, *args): 
        """
        __init__(self) -> CsoundRandMT
        __init__(self, uint32_t seedVal) -> CsoundRandMT
        __init__(self, uint32_t initKey, int keyLength) -> CsoundRandMT
        """
        this = _csnd.new_CsoundRandMT(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundRandMT
    __del__ = lambda self : None;
CsoundRandMT_swigregister = _csnd.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(self) -> double"""
        return _csnd.CsoundTimer_GetRealTime(self)

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

    def Reset(self):
        """Reset(self)"""
        return _csnd.CsoundTimer_Reset(self)

    def __init__(self): 
        """__init__(self) -> CsoundTimer"""
        this = _csnd.new_CsoundTimer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundTimer
    __del__ = lambda self : None;
CsoundTimer_swigregister = _csnd.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(self) -> int"""
        return _csnd.CsoundOpcodeList_Count(self)

    def Name(self, *args):
        """Name(self, int ndx) -> char"""
        return _csnd.CsoundOpcodeList_Name(self, *args)

    def OutTypes(self, *args):
        """OutTypes(self, int ndx) -> char"""
        return _csnd.CsoundOpcodeList_OutTypes(self, *args)

    def InTypes(self, *args):
        """InTypes(self, int ndx) -> char"""
        return _csnd.CsoundOpcodeList_InTypes(self, *args)

    def Clear(self):
        """Clear(self)"""
        return _csnd.CsoundOpcodeList_Clear(self)

    def __init__(self, *args): 
        """
        __init__(self, CSOUND csound) -> CsoundOpcodeList
        __init__(self, Csound csound) -> CsoundOpcodeList
        """
        this = _csnd.new_CsoundOpcodeList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundOpcodeList
    __del__ = lambda self : None;
CsoundOpcodeList_swigregister = _csnd.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(self) -> int"""
        return _csnd.CsoundChannelList_Count(self)

    def Name(self, *args):
        """Name(self, int ndx) -> char"""
        return _csnd.CsoundChannelList_Name(self, *args)

    def Type(self, *args):
        """Type(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_Type(self, *args)

    def IsControlChannel(self, *args):
        """IsControlChannel(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_IsControlChannel(self, *args)

    def IsAudioChannel(self, *args):
        """IsAudioChannel(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_IsAudioChannel(self, *args)

    def IsStringChannel(self, *args):
        """IsStringChannel(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_IsStringChannel(self, *args)

    def IsInputChannel(self, *args):
        """IsInputChannel(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_IsInputChannel(self, *args)

    def IsOutputChannel(self, *args):
        """IsOutputChannel(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_IsOutputChannel(self, *args)

    def SubType(self, *args):
        """SubType(self, int ndx) -> int"""
        return _csnd.CsoundChannelList_SubType(self, *args)

    def DefaultValue(self, *args):
        """DefaultValue(self, int ndx) -> double"""
        return _csnd.CsoundChannelList_DefaultValue(self, *args)

    def MinValue(self, *args):
        """MinValue(self, int ndx) -> double"""
        return _csnd.CsoundChannelList_MinValue(self, *args)

    def MaxValue(self, *args):
        """MaxValue(self, int ndx) -> double"""
        return _csnd.CsoundChannelList_MaxValue(self, *args)

    def Clear(self):
        """Clear(self)"""
        return _csnd.CsoundChannelList_Clear(self)

    def __init__(self, *args): 
        """
        __init__(self, CSOUND csound) -> CsoundChannelList
        __init__(self, Csound csound) -> CsoundChannelList
        """
        this = _csnd.new_CsoundChannelList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundChannelList
    __del__ = lambda self : None;
CsoundChannelList_swigregister = _csnd.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(self) -> int"""
        return _csnd.CsoundUtilityList_Count(self)

    def Name(self, *args):
        """Name(self, int ndx) -> char"""
        return _csnd.CsoundUtilityList_Name(self, *args)

    def Clear(self):
        """Clear(self)"""
        return _csnd.CsoundUtilityList_Clear(self)

    def __init__(self, *args): 
        """
        __init__(self, CSOUND csound) -> CsoundUtilityList
        __init__(self, Csound csound) -> CsoundUtilityList
        """
        this = _csnd.new_CsoundUtilityList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundUtilityList
    __del__ = lambda self : None;
CsoundUtilityList_swigregister = _csnd.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(self) -> float
        GetPtr(self, int ndx) -> float
        """
        return _csnd.CsoundMYFLTArray_GetPtr(self, *args)

    def SetPtr(self, *args):
        """SetPtr(self, float ptr)"""
        return _csnd.CsoundMYFLTArray_SetPtr(self, *args)

    def SetValue(self, *args):
        """SetValue(self, int ndx, double value)"""
        return _csnd.CsoundMYFLTArray_SetValue(self, *args)

    def GetValue(self, *args):
        """GetValue(self, int ndx) -> double"""
        return _csnd.CsoundMYFLTArray_GetValue(self, *args)

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

    def GetValues(self, *args):
        """GetValues(self, float dst, int ndx, int n)"""
        return _csnd.CsoundMYFLTArray_GetValues(self, *args)

    def SetStringValue(self, *args):
        """SetStringValue(self, char s, int maxLen)"""
        return _csnd.CsoundMYFLTArray_SetStringValue(self, *args)

    def GetStringValue(self):
        """GetStringValue(self) -> char"""
        return _csnd.CsoundMYFLTArray_GetStringValue(self)

    def Clear(self):
        """Clear(self)"""
        return _csnd.CsoundMYFLTArray_Clear(self)

    def __init__(self, *args): 
        """
        __init__(self) -> CsoundMYFLTArray
        __init__(self, int n) -> CsoundMYFLTArray
        """
        this = _csnd.new_CsoundMYFLTArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMYFLTArray
    __del__ = lambda self : None;
CsoundMYFLTArray_swigregister = _csnd.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(self) -> int"""
        return _csnd.CsoundArgVList_argc(self)

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

    def Insert(self, *args):
        """Insert(self, int ndx, char s)"""
        return _csnd.CsoundArgVList_Insert(self, *args)

    def Append(self, *args):
        """Append(self, char s)"""
        return _csnd.CsoundArgVList_Append(self, *args)

    def Clear(self):
        """Clear(self)"""
        return _csnd.CsoundArgVList_Clear(self)

    def __init__(self): 
        """__init__(self) -> CsoundArgVList"""
        this = _csnd.new_CsoundArgVList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundArgVList
    __del__ = lambda self : None;
CsoundArgVList_swigregister = _csnd.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, *args):
        """MessageCallback(self, int attr, char msg)"""
        return _csnd.CsoundCallbackWrapper_MessageCallback(self, *args)

    def InputValueCallback(self, *args):
        """InputValueCallback(self, char chnName) -> double"""
        return _csnd.CsoundCallbackWrapper_InputValueCallback(self, *args)

    def OutputValueCallback(self, *args):
        """OutputValueCallback(self, char chnName, double value)"""
        return _csnd.CsoundCallbackWrapper_OutputValueCallback(self, *args)

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

    def MidiInputCallback(self, *args):
        """MidiInputCallback(self, CsoundMidiInputBuffer p)"""
        return _csnd.CsoundCallbackWrapper_MidiInputCallback(self, *args)

    def MidiOutputCallback(self, *args):
        """MidiOutputCallback(self, CsoundMidiOutputBuffer p)"""
        return _csnd.CsoundCallbackWrapper_MidiOutputCallback(self, *args)

    def ControlChannelInputCallback(self, *args):
        """ControlChannelInputCallback(self, char chnName) -> double"""
        return _csnd.CsoundCallbackWrapper_ControlChannelInputCallback(self, *args)

    def ControlChannelOutputCallback(self, *args):
        """ControlChannelOutputCallback(self, char chnName, double value)"""
        return _csnd.CsoundCallbackWrapper_ControlChannelOutputCallback(self, *args)

    def StringChannelInputCallback(self, *args):
        """StringChannelInputCallback(self, char chnName) -> char"""
        return _csnd.CsoundCallbackWrapper_StringChannelInputCallback(self, *args)

    def StringChannelOutputCallback(self, *args):
        """StringChannelOutputCallback(self, char chnName, char value)"""
        return _csnd.CsoundCallbackWrapper_StringChannelOutputCallback(self, *args)

    def SetMessageCallback(self):
        """SetMessageCallback(self)"""
        return _csnd.CsoundCallbackWrapper_SetMessageCallback(self)

    def SetInputValueCallback(self):
        """SetInputValueCallback(self)"""
        return _csnd.CsoundCallbackWrapper_SetInputValueCallback(self)

    def SetOutputValueCallback(self):
        """SetOutputValueCallback(self)"""
        return _csnd.CsoundCallbackWrapper_SetOutputValueCallback(self)

    def SetYieldCallback(self):
        """SetYieldCallback(self)"""
        return _csnd.CsoundCallbackWrapper_SetYieldCallback(self)

    def SetMidiInputCallback(self, *args):
        """SetMidiInputCallback(self, CsoundArgVList argv)"""
        return _csnd.CsoundCallbackWrapper_SetMidiInputCallback(self, *args)

    def SetMidiOutputCallback(self, *args):
        """SetMidiOutputCallback(self, CsoundArgVList argv)"""
        return _csnd.CsoundCallbackWrapper_SetMidiOutputCallback(self, *args)

    def SetChannelIOCallbacks(self):
        """SetChannelIOCallbacks(self)"""
        return _csnd.CsoundCallbackWrapper_SetChannelIOCallbacks(self)

    def GetCsound(self):
        """GetCsound(self) -> CSOUND"""
        return _csnd.CsoundCallbackWrapper_GetCsound(self)

    def CharPtrToString(*args):
        """CharPtrToString(char s) -> char"""
        return _csnd.CsoundCallbackWrapper_CharPtrToString(*args)

    if _newclass:CharPtrToString = staticmethod(CharPtrToString)
    __swig_getmethods__["CharPtrToString"] = lambda x: CharPtrToString
    def __init__(self, *args): 
        """
        __init__(self, Csound csound) -> CsoundCallbackWrapper
        __init__(self, CSOUND csound) -> CsoundCallbackWrapper
        """
        if self.__class__ == CsoundCallbackWrapper:
            _self = None
        else:
            _self = self
        this = _csnd.new_CsoundCallbackWrapper(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundCallbackWrapper
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _csnd.disown_CsoundCallbackWrapper(self)
        return weakref_proxy(self)
CsoundCallbackWrapper_swigregister = _csnd.CsoundCallbackWrapper_swigregister
CsoundCallbackWrapper_swigregister(CsoundCallbackWrapper)

def CsoundCallbackWrapper_CharPtrToString(*args):
  """CsoundCallbackWrapper_CharPtrToString(char s) -> char"""
  return _csnd.CsoundCallbackWrapper_CharPtrToString(*args)

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, *args): 
        """__init__(self, unsigned char buf, int bufSize) -> CsoundMidiInputBuffer"""
        this = _csnd.new_CsoundMidiInputBuffer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMidiInputBuffer
    __del__ = lambda self : None;
    def SendMessage(self, *args):
        """
        SendMessage(self, int msg)
        SendMessage(self, int status, int channel, int data1, int data2)
        """
        return _csnd.CsoundMidiInputBuffer_SendMessage(self, *args)

    def SendNoteOn(self, *args):
        """SendNoteOn(self, int channel, int key, int velocity)"""
        return _csnd.CsoundMidiInputBuffer_SendNoteOn(self, *args)

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

    def SendPolyphonicPressure(self, *args):
        """SendPolyphonicPressure(self, int channel, int key, int value)"""
        return _csnd.CsoundMidiInputBuffer_SendPolyphonicPressure(self, *args)

    def SendControlChange(self, *args):
        """SendControlChange(self, int channel, int ctl, int value)"""
        return _csnd.CsoundMidiInputBuffer_SendControlChange(self, *args)

    def SendProgramChange(self, *args):
        """SendProgramChange(self, int channel, int pgm)"""
        return _csnd.CsoundMidiInputBuffer_SendProgramChange(self, *args)

    def SendChannelPressure(self, *args):
        """SendChannelPressure(self, int channel, int value)"""
        return _csnd.CsoundMidiInputBuffer_SendChannelPressure(self, *args)

    def SendPitchBend(self, *args):
        """SendPitchBend(self, int channel, int value)"""
        return _csnd.CsoundMidiInputBuffer_SendPitchBend(self, *args)

CsoundMidiInputBuffer_swigregister = _csnd.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__(self, CSOUND csound) -> CsoundMidiInputStream
        __init__(self, Csound csound) -> CsoundMidiInputStream
        """
        this = _csnd.new_CsoundMidiInputStream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMidiInputStream
    __del__ = lambda self : None;
    def EnableMidiInput(self, *args):
        """EnableMidiInput(self, CsoundArgVList argv)"""
        return _csnd.CsoundMidiInputStream_EnableMidiInput(self, *args)

CsoundMidiInputStream_swigregister = _csnd.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, *args): 
        """__init__(self, unsigned char buf, int bufSize) -> CsoundMidiOutputBuffer"""
        this = _csnd.new_CsoundMidiOutputBuffer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMidiOutputBuffer
    __del__ = lambda self : None;
    def PopMessage(self):
        """PopMessage(self) -> int"""
        return _csnd.CsoundMidiOutputBuffer_PopMessage(self)

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

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

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

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

CsoundMidiOutputBuffer_swigregister = _csnd.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__(self, CSOUND csound) -> CsoundMidiOutputStream
        __init__(self, Csound csound) -> CsoundMidiOutputStream
        """
        this = _csnd.new_CsoundMidiOutputStream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundMidiOutputStream
    __del__ = lambda self : None;
    def EnableMidiOutput(self, *args):
        """EnableMidiOutput(self, CsoundArgVList argv)"""
        return _csnd.CsoundMidiOutputStream_EnableMidiOutput(self, *args)

CsoundMidiOutputStream_swigregister = _csnd.CsoundMidiOutputStream_swigregister
CsoundMidiOutputStream_swigregister(CsoundMidiOutputStream)

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"] = _csnd.pycallbackdata_func_set
    __swig_getmethods__["func"] = _csnd.pycallbackdata_func_get
    if _newclass:func = _swig_property(_csnd.pycallbackdata_func_get, _csnd.pycallbackdata_func_set)
    __swig_setmethods__["data"] = _csnd.pycallbackdata_data_set
    __swig_getmethods__["data"] = _csnd.pycallbackdata_data_get
    if _newclass:data = _swig_property(_csnd.pycallbackdata_data_get, _csnd.pycallbackdata_data_set)
    def __init__(self): 
        """__init__(self) -> pycallbackdata"""
        this = _csnd.new_pycallbackdata()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_pycallbackdata
    __del__ = lambda self : None;
pycallbackdata_swigregister = _csnd.pycallbackdata_swigregister
pycallbackdata_swigregister(pycallbackdata)

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"] = _csnd.CsoundPerformanceThread__tstate_set
    __swig_getmethods__["_tstate"] = _csnd.CsoundPerformanceThread__tstate_get
    if _newclass:_tstate = _swig_property(_csnd.CsoundPerformanceThread__tstate_get, _csnd.CsoundPerformanceThread__tstate_set)
    __swig_setmethods__["pydata"] = _csnd.CsoundPerformanceThread_pydata_set
    __swig_getmethods__["pydata"] = _csnd.CsoundPerformanceThread_pydata_get
    if _newclass:pydata = _swig_property(_csnd.CsoundPerformanceThread_pydata_get, _csnd.CsoundPerformanceThread_pydata_set)
    def GetProcessCallback(self):
        """GetProcessCallback(self) -> void"""
        return _csnd.CsoundPerformanceThread_GetProcessCallback(self)

    def GetCsound(self):
        """GetCsound(self) -> CSOUND"""
        return _csnd.CsoundPerformanceThread_GetCsound(self)

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

    def Play(self):
        """Play(self)"""
        return _csnd.CsoundPerformanceThread_Play(self)

    def Pause(self):
        """Pause(self)"""
        return _csnd.CsoundPerformanceThread_Pause(self)

    def TogglePause(self):
        """TogglePause(self)"""
        return _csnd.CsoundPerformanceThread_TogglePause(self)

    def Stop(self):
        """Stop(self)"""
        return _csnd.CsoundPerformanceThread_Stop(self)

    def ScoreEvent(self, *args):
        """ScoreEvent(self, int absp2mode, char opcod, int pcnt, float p)"""
        return _csnd.CsoundPerformanceThread_ScoreEvent(self, *args)

    def InputMessage(self, *args):
        """InputMessage(self, char s)"""
        return _csnd.CsoundPerformanceThread_InputMessage(self, *args)

    def SetScoreOffsetSeconds(self, *args):
        """SetScoreOffsetSeconds(self, double timeVal)"""
        return _csnd.CsoundPerformanceThread_SetScoreOffsetSeconds(self, *args)

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

    def FlushMessageQueue(self):
        """FlushMessageQueue(self)"""
        return _csnd.CsoundPerformanceThread_FlushMessageQueue(self)

    def __init__(self, *args): 
        """
        __init__(self, Csound arg0) -> CsoundPerformanceThread
        __init__(self, CSOUND arg0) -> CsoundPerformanceThread
        """
        this = _csnd.new_CsoundPerformanceThread(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundPerformanceThread
    __del__ = lambda self : None;
    def SetProcessCallback(self, *args):
        """SetProcessCallback(self, PyObject pyfunc, PyObject p)"""
        return _csnd.CsoundPerformanceThread_SetProcessCallback(self, *args)

CsoundPerformanceThread_swigregister = _csnd.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(self) -> SwigPyIterator"""
        return _csnd.IntToStringMap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _csnd.IntToStringMap___nonzero__(self)

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _csnd.IntToStringMap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _csnd.IntToStringMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _csnd.IntToStringMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _csnd.IntToStringMap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _csnd.IntToStringMap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _csnd.IntToStringMap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _csnd.IntToStringMap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _csnd.IntToStringMap___contains__(self, *args)

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

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _csnd.IntToStringMap_value_iterator(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 __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _csnd.IntToStringMap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(int)> arg0) -> IntToStringMap
        __init__(self) -> IntToStringMap
        __init__(self, IntToStringMap arg0) -> IntToStringMap
        """
        this = _csnd.new_IntToStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _csnd.IntToStringMap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _csnd.IntToStringMap_size(self)

    def clear(self):
        """clear(self)"""
        return _csnd.IntToStringMap_clear(self)

    def swap(self, *args):
        """swap(self, IntToStringMap v)"""
        return _csnd.IntToStringMap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _csnd.IntToStringMap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _csnd.IntToStringMap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _csnd.IntToStringMap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _csnd.IntToStringMap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _csnd.IntToStringMap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _csnd.IntToStringMap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _csnd.IntToStringMap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _csnd.IntToStringMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _csnd.IntToStringMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _csnd.IntToStringMap_upper_bound(self, *args)

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


def gatherArgs(*args):
  """gatherArgs(int argc, char argv, string commandLine)"""
  return _csnd.gatherArgs(*args)

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

def trim(*args):
  """trim(string value) -> string"""
  return _csnd.trim(*args)

def trimQuotes(*args):
  """trimQuotes(string value) -> string"""
  return _csnd.trimQuotes(*args)

def parseInstrument(*args):
  """
    parseInstrument(string definition, string preNumber, string id, string name, 
        string postNumber) -> bool
    """
  return _csnd.parseInstrument(*args)
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"] = _csnd.CsoundFile_libraryFilename_set
    __swig_getmethods__["libraryFilename"] = _csnd.CsoundFile_libraryFilename_get
    if _newclass:libraryFilename = _swig_property(_csnd.CsoundFile_libraryFilename_get, _csnd.CsoundFile_libraryFilename_set)
    __swig_setmethods__["arrangement"] = _csnd.CsoundFile_arrangement_set
    __swig_getmethods__["arrangement"] = _csnd.CsoundFile_arrangement_get
    if _newclass:arrangement = _swig_property(_csnd.CsoundFile_arrangement_get, _csnd.CsoundFile_arrangement_set)
    def __init__(self): 
        """__init__(self) -> CsoundFile"""
        this = _csnd.new_CsoundFile()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CsoundFile
    __del__ = lambda self : None;
    def generateFilename(self):
        """generateFilename(self) -> string"""
        return _csnd.CsoundFile_generateFilename(self)

    def getFilename(self):
        """getFilename(self) -> string"""
        return _csnd.CsoundFile_getFilename(self)

    def setFilename(self, *args):
        """setFilename(self, string name)"""
        return _csnd.CsoundFile_setFilename(self, *args)

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

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

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

    def importCommand(self, *args):
        """importCommand(self, std::istream stream) -> int"""
        return _csnd.CsoundFile_importCommand(self, *args)

    def exportCommand(self, *args):
        """exportCommand(self, std::ostream stream) -> int"""
        return _csnd.CsoundFile_exportCommand(self, *args)

    def importOrchestra(self, *args):
        """importOrchestra(self, std::istream stream) -> int"""
        return _csnd.CsoundFile_importOrchestra(self, *args)

    def exportOrchestra(self, *args):
        """exportOrchestra(self, std::ostream stream) -> int"""
        return _csnd.CsoundFile_exportOrchestra(self, *args)

    def importScore(self, *args):
        """importScore(self, std::istream stream) -> int"""
        return _csnd.CsoundFile_importScore(self, *args)

    def exportScore(self, *args):
        """exportScore(self, std::ostream stream) -> int"""
        return _csnd.CsoundFile_exportScore(self, *args)

    def importArrangement(self, *args):
        """importArrangement(self, std::istream stream) -> int"""
        return _csnd.CsoundFile_importArrangement(self, *args)

    def exportArrangement(self, *args):
        """exportArrangement(self, std::ostream stream) -> int"""
        return _csnd.CsoundFile_exportArrangement(self, *args)

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

    def importMidifile(self, *args):
        """importMidifile(self, std::istream stream) -> int"""
        return _csnd.CsoundFile_importMidifile(self, *args)

    def exportMidifile(self, *args):
        """exportMidifile(self, std::ostream stream) -> int"""
        return _csnd.CsoundFile_exportMidifile(self, *args)

    def getCommand(self):
        """getCommand(self) -> string"""
        return _csnd.CsoundFile_getCommand(self)

    def setCommand(self, *args):
        """setCommand(self, string commandLine)"""
        return _csnd.CsoundFile_setCommand(self, *args)

    def getOrcFilename(self):
        """getOrcFilename(self) -> string"""
        return _csnd.CsoundFile_getOrcFilename(self)

    def getScoFilename(self):
        """getScoFilename(self) -> string"""
        return _csnd.CsoundFile_getScoFilename(self)

    def getMidiFilename(self):
        """getMidiFilename(self) -> string"""
        return _csnd.CsoundFile_getMidiFilename(self)

    def getOutputSoundfileName(self):
        """getOutputSoundfileName(self) -> string"""
        return _csnd.CsoundFile_getOutputSoundfileName(self)

    def getOrchestra(self):
        """getOrchestra(self) -> string"""
        return _csnd.CsoundFile_getOrchestra(self)

    def setOrchestra(self, *args):
        """setOrchestra(self, string orchestra)"""
        return _csnd.CsoundFile_setOrchestra(self, *args)

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

    def getOrchestraHeader(self):
        """getOrchestraHeader(self) -> string"""
        return _csnd.CsoundFile_getOrchestraHeader(self)

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

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

    def getScore(self):
        """getScore(self) -> string"""
        return _csnd.CsoundFile_getScore(self)

    def setScore(self, *args):
        """setScore(self, string score)"""
        return _csnd.CsoundFile_setScore(self, *args)

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

    def getArrangement(self, *args):
        """getArrangement(self, int index) -> string"""
        return _csnd.CsoundFile_getArrangement(self, *args)

    def addArrangement(self, *args):
        """addArrangement(self, string instrument)"""
        return _csnd.CsoundFile_addArrangement(self, *args)

    def setArrangement(self, *args):
        """setArrangement(self, int index, string instrument)"""
        return _csnd.CsoundFile_setArrangement(self, *args)

    def insertArrangement(self, *args):
        """insertArrangement(self, int index, string instrument)"""
        return _csnd.CsoundFile_insertArrangement(self, *args)

    def setCSD(self, *args):
        """setCSD(self, string xml)"""
        return _csnd.CsoundFile_setCSD(self, *args)

    def getCSD(self):
        """getCSD(self) -> string"""
        return _csnd.CsoundFile_getCSD(self)

    def addScoreLine(self, *args):
        """addScoreLine(self, string line)"""
        return _csnd.CsoundFile_addScoreLine(self, *args)

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

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

    def removeAll(self):
        """removeAll(self)"""
        return _csnd.CsoundFile_removeAll(self)

    def removeCommand(self):
        """removeCommand(self)"""
        return _csnd.CsoundFile_removeCommand(self)

    def removeOrchestra(self):
        """removeOrchestra(self)"""
        return _csnd.CsoundFile_removeOrchestra(self)

    def removeScore(self):
        """removeScore(self)"""
        return _csnd.CsoundFile_removeScore(self)

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

    def removeMidifile(self):
        """removeMidifile(self)"""
        return _csnd.CsoundFile_removeMidifile(self)

    def loadOrcLibrary(self, filename = None):
        """
        loadOrcLibrary(self, char filename = None) -> bool
        loadOrcLibrary(self) -> bool
        """
        return _csnd.CsoundFile_loadOrcLibrary(self, filename)

CsoundFile_swigregister = _csnd.CsoundFile_swigregister
CsoundFile_swigregister(CsoundFile)

class MyfltVector(_object):
    """Proxy of C++ std::vector<(float)> 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(self) -> SwigPyIterator"""
        return _csnd.MyfltVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _csnd.MyfltVector___nonzero__(self)

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

    def __len__(self):
        """__len__(self) -> size_type"""
        return _csnd.MyfltVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _csnd.MyfltVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> MyfltVector"""
        return _csnd.MyfltVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, MyfltVector v)"""
        return _csnd.MyfltVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _csnd.MyfltVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _csnd.MyfltVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> MyfltVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _csnd.MyfltVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, MyfltVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _csnd.MyfltVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _csnd.MyfltVector_append(self, *args)

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

    def size(self):
        """size(self) -> size_type"""
        return _csnd.MyfltVector_size(self)

    def clear(self):
        """clear(self)"""
        return _csnd.MyfltVector_clear(self)

    def swap(self, *args):
        """swap(self, MyfltVector v)"""
        return _csnd.MyfltVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _csnd.MyfltVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _csnd.MyfltVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _csnd.MyfltVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _csnd.MyfltVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _csnd.MyfltVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _csnd.MyfltVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _csnd.MyfltVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> MyfltVector
        __init__(self, MyfltVector arg0) -> MyfltVector
        __init__(self, size_type size) -> MyfltVector
        __init__(self, size_type size, value_type value) -> MyfltVector
        """
        this = _csnd.new_MyfltVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _csnd.MyfltVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _csnd.MyfltVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _csnd.MyfltVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _csnd.MyfltVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _csnd.MyfltVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _csnd.MyfltVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _csnd.MyfltVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _csnd.MyfltVector_capacity(self)

    __swig_destroy__ = _csnd.delete_MyfltVector
    __del__ = lambda self : None;
MyfltVector_swigregister = _csnd.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__(self) -> CppSound"""
        this = _csnd.new_CppSound()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_CppSound
    __del__ = lambda self : None;
    def getCsound(self):
        """getCsound(self) -> CSOUND"""
        return _csnd.CppSound_getCsound(self)

    def getThis(self):
        """getThis(self) -> long"""
        return _csnd.CppSound_getThis(self)

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

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

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

    def getOutputSoundfileName(self):
        """getOutputSoundfileName(self) -> string"""
        return _csnd.CppSound_getOutputSoundfileName(self)

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

    def performKsmps(self, *args):
        """performKsmps(self, bool absolute) -> int"""
        return _csnd.CppSound_performKsmps(self, *args)

    def cleanup(self):
        """cleanup(self)"""
        return _csnd.CppSound_cleanup(self)

    def inputMessage(self, *args):
        """inputMessage(self, char istatement)"""
        return _csnd.CppSound_inputMessage(self, *args)

    def write(self, *args):
        """write(self, char text)"""
        return _csnd.CppSound_write(self, *args)

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

    def setIsPerforming(self, *args):
        """setIsPerforming(self, bool isPerforming)"""
        return _csnd.CppSound_setIsPerforming(self, *args)

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

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

    def stop(self):
        """stop(self)"""
        return _csnd.CppSound_stop(self)

    def setPythonMessageCallback(self):
        """setPythonMessageCallback(self)"""
        return _csnd.CppSound_setPythonMessageCallback(self)

CppSound_swigregister = _csnd.CppSound_swigregister
CppSound_swigregister(CppSound)



