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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_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):
        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 - class is abstract")
    __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_WVE = _csnd.CSFTYPE_WVE
CSFTYPE_OGG = _csnd.CSFTYPE_OGG
CSFTYPE_MPC2K = _csnd.CSFTYPE_MPC2K
CSFTYPE_RF64 = _csnd.CSFTYPE_RF64
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_IMAGE_PNG = _csnd.CSFTYPE_IMAGE_PNG
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__(csRtAudioParams 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_S class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RTCLOCK, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RTCLOCK, name)
    __repr__ = _swig_repr
    __swig_setmethods__["starttime_real"] = _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__(RTCLOCK_S 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__(opcodeListEntry 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__(CsoundRandMTState_ 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__(CsoundChannelListEntry_ 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++ pvsdat_ext class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PVSDATEXT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PVSDATEXT, name)
    __repr__ = _swig_repr
    __swig_setmethods__["N"] = _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__(pvsdat_ext 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)

class TABDAT(_object):
    """Proxy of C++ TABDAT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TABDAT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TABDAT, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _csnd.TABDAT_size_set
    __swig_getmethods__["size"] = _csnd.TABDAT_size_get
    if _newclass:size = _swig_property(_csnd.TABDAT_size_get, _csnd.TABDAT_size_set)
    __swig_setmethods__["data"] = _csnd.TABDAT_data_set
    __swig_getmethods__["data"] = _csnd.TABDAT_data_get
    if _newclass:data = _swig_property(_csnd.TABDAT_data_get, _csnd.TABDAT_data_set)
    def __init__(self): 
        """__init__(TABDAT self) -> TABDAT"""
        this = _csnd.new_TABDAT()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_TABDAT
    __del__ = lambda self : None;
TABDAT_swigregister = _csnd.TABDAT_swigregister
TABDAT_swigregister(TABDAT)


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 * arg1) -> int"""
  return _csnd.csoundPreCompile(*args)

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

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

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

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

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

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

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

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

def csoundCompileFromStrings(*args):
  """csoundCompileFromStrings(CSOUND * arg1, char * orchst, char * scorst, int argc, char ** argv) -> int"""
  return _csnd.csoundCompileFromStrings(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def csoundCreateThread(*args):
  """csoundCreateThread(uintptr_t (*)(void *) 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 const *const * 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(RTCLOCK arg1)"""
  return _csnd.csoundInitTimerStruct(*args)

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

def csoundGetCPUTime(*args):
  """csoundGetCPUTime(RTCLOCK arg1) -> 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 const * s) -> char *"""
  return _csnd.csoundLocalizeString(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def csoundChanIASet(*args):
  """csoundChanIASet(CSOUND * arg1, double const * value, int n) -> int"""
  return _csnd.csoundChanIASet(*args)

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

def csoundChanIKSetValue(*args):
  """csoundChanIKSetValue(CSOUND * arg1, int channel, double value) -> int"""
  return _csnd.csoundChanIKSetValue(*args)

def csoundChanOKGetValue(*args):
  """csoundChanOKGetValue(CSOUND * arg1, int channel) -> double"""
  return _csnd.csoundChanOKGetValue(*args)

def csoundChanIASetSample(*args):
  """csoundChanIASetSample(CSOUND * arg1, int channel, int frame, double sample) -> int"""
  return _csnd.csoundChanIASetSample(*args)

def csoundChanOAGetSample(*args):
  """csoundChanOAGetSample(CSOUND * arg1, int channel, int frame) -> double"""
  return _csnd.csoundChanOAGetSample(*args)

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

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

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

def csoundRemoveCallback(*args):
  """csoundRemoveCallback(CSOUND * arg1, int (*)(void *,void *,unsigned 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 const *"""
  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)
class csCfgVariableHead_t(_object):
    """Proxy of C++ csCfgVariableHead_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableHead_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableHead_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableHead_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableInt_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableInt_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableInt_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableBoolean_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableBoolean_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableBoolean_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableFloat_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableFloat_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableFloat_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableDouble_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableDouble_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableDouble_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableMYFLT_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableMYFLT_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableMYFLT_s 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_s class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariableString_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariableString_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nxt"] = _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__(csCfgVariableString_s 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_u class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csCfgVariable_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csCfgVariable_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["h"] = _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__(csCfgVariable_u 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 const * name, void * p, int type, int flags, void * min, void * max, 
        char const * shortDesc, char const * longDesc) -> int
    """
  return _csnd.csoundCreateConfigurationVariable(*args)

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

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

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

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

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

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

def csoundCfgErrorCodeToString(*args):
  """csoundCfgErrorCodeToString(int errcode) -> char const *"""
  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
VERSION = _csnd.VERSION
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

def csoundSpinInit(*args):
  """csoundSpinInit(pthread_spinlock_t * spinlock) -> int"""
  return _csnd.csoundSpinInit(*args)

def csoundSpinLock(*args):
  """csoundSpinLock(pthread_spinlock_t * spinlock) -> int"""
  return _csnd.csoundSpinLock(*args)

def csoundSpinUnLock(*args):
  """csoundSpinUnLock(pthread_spinlock_t * spinlock) -> int"""
  return _csnd.csoundSpinUnLock(*args)

def csoundSpinDestroy(*args):
  """csoundSpinDestroy(pthread_spinlock_t volatile * spinlock) -> int"""
  return _csnd.csoundSpinDestroy(*args)

def csoundCreateCircularBuffer(*args):
  """csoundCreateCircularBuffer(CSOUND * csound, int size) -> void *"""
  return _csnd.csoundCreateCircularBuffer(*args)

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

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

def csoundFreeCircularBuffer(*args):
  """csoundFreeCircularBuffer(CSOUND * csound, void * circularbuffer)"""
  return _csnd.csoundFreeCircularBuffer(*args)
MESSAGE_BUFFER_LENGTH = _csnd.MESSAGE_BUFFER_LENGTH
class pycbdata(_object):
    """Proxy of C++ pycbdata class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pycbdata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pycbdata, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mfunc"] = _csnd.pycbdata_mfunc_set
    __swig_getmethods__["mfunc"] = _csnd.pycbdata_mfunc_get
    if _newclass:mfunc = _swig_property(_csnd.pycbdata_mfunc_get, _csnd.pycbdata_mfunc_set)
    __swig_setmethods__["invalfunc"] = _csnd.pycbdata_invalfunc_set
    __swig_getmethods__["invalfunc"] = _csnd.pycbdata_invalfunc_get
    if _newclass:invalfunc = _swig_property(_csnd.pycbdata_invalfunc_get, _csnd.pycbdata_invalfunc_set)
    __swig_setmethods__["outvalfunc"] = _csnd.pycbdata_outvalfunc_set
    __swig_getmethods__["outvalfunc"] = _csnd.pycbdata_outvalfunc_get
    if _newclass:outvalfunc = _swig_property(_csnd.pycbdata_outvalfunc_get, _csnd.pycbdata_outvalfunc_set)
    __swig_setmethods__["midiinopenfunc"] = _csnd.pycbdata_midiinopenfunc_set
    __swig_getmethods__["midiinopenfunc"] = _csnd.pycbdata_midiinopenfunc_get
    if _newclass:midiinopenfunc = _swig_property(_csnd.pycbdata_midiinopenfunc_get, _csnd.pycbdata_midiinopenfunc_set)
    __swig_setmethods__["midireadfunc"] = _csnd.pycbdata_midireadfunc_set
    __swig_getmethods__["midireadfunc"] = _csnd.pycbdata_midireadfunc_get
    if _newclass:midireadfunc = _swig_property(_csnd.pycbdata_midireadfunc_get, _csnd.pycbdata_midireadfunc_set)
    __swig_setmethods__["midiinclosefunc"] = _csnd.pycbdata_midiinclosefunc_set
    __swig_getmethods__["midiinclosefunc"] = _csnd.pycbdata_midiinclosefunc_get
    if _newclass:midiinclosefunc = _swig_property(_csnd.pycbdata_midiinclosefunc_get, _csnd.pycbdata_midiinclosefunc_set)
    __swig_setmethods__["hostdata"] = _csnd.pycbdata_hostdata_set
    __swig_getmethods__["hostdata"] = _csnd.pycbdata_hostdata_get
    if _newclass:hostdata = _swig_property(_csnd.pycbdata_hostdata_get, _csnd.pycbdata_hostdata_set)
    __swig_setmethods__["messageBuffer"] = _csnd.pycbdata_messageBuffer_set
    __swig_getmethods__["messageBuffer"] = _csnd.pycbdata_messageBuffer_get
    if _newclass:messageBuffer = _swig_property(_csnd.pycbdata_messageBuffer_get, _csnd.pycbdata_messageBuffer_set)
    __swig_setmethods__["messageBufferIndex"] = _csnd.pycbdata_messageBufferIndex_set
    __swig_getmethods__["messageBufferIndex"] = _csnd.pycbdata_messageBufferIndex_get
    if _newclass:messageBufferIndex = _swig_property(_csnd.pycbdata_messageBufferIndex_get, _csnd.pycbdata_messageBufferIndex_set)
    def __init__(self): 
        """__init__(pycbdata self) -> pycbdata"""
        this = _csnd.new_pycbdata()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _csnd.delete_pycbdata
    __del__ = lambda self : None;
pycbdata_swigregister = _csnd.pycbdata_swigregister
pycbdata_swigregister(pycbdata)

class Csound(_object):
    """Proxy of C++ Csound class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Csound, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Csound, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pydata"] = _csnd.Csound_pydata_set
    __swig_getmethods__["pydata"] = _csnd.Csound_pydata_get
    if _newclass:pydata = _swig_property(_csnd.Csound_pydata_get, _csnd.Csound_pydata_set)
    def GetCsound(self):
        """GetCsound(Csound self) -> CSOUND *"""
        return _csnd.Csound_GetCsound(self)

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

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

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

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

    def CompileFromStrings(self, *args):
        """
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None, char * arg2=None, char * arg3=None, 
            char * arg4=None, char * arg5=None, char * arg6=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None, char * arg2=None, char * arg3=None, 
            char * arg4=None, char * arg5=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None, char * arg2=None, char * arg3=None, 
            char * arg4=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None, char * arg2=None, char * arg3=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None, char * arg2=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, char * arg1=None) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr) -> int
        CompileFromStrings(Csound self, char * orcstr, char * scorstr, int argc, char ** argv) -> int
        """
        return _csnd.Csound_CompileFromStrings(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def KeyPressed(self, *args):
        """KeyPressed(Csound self, char c)"""
        return _csnd.Csound_KeyPressed(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def QueryConfigurationVariable(self, *args):
        """QueryConfigurationVariable(Csound self, char const * name) -> csCfgVariable_t"""
        return _csnd.Csound_QueryConfigurationVariable(self, *args)

    def ListConfigurationVariables(self):
        """ListConfigurationVariables(Csound self) -> csCfgVariable_t **"""
        return _csnd.Csound_ListConfigurationVariables(self)

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

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

    def __init__(self, *args): 
        """
        __init__(Csound self) -> Csound
        __init__(Csound 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(Csound self, int toStdOut)"""
        return _csnd.Csound_EnableMessageBuffer(self, *args)

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

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

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

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

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

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

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

    def ChanIKSetValue(self, *args):
        """ChanIKSetValue(Csound self, int channel, double value) -> int"""
        return _csnd.Csound_ChanIKSetValue(self, *args)

    def ChanOKGetValue(self, *args):
        """ChanOKGetValue(Csound self, int channel) -> double"""
        return _csnd.Csound_ChanOKGetValue(self, *args)

    def ChanIASetSample(self, *args):
        """ChanIASetSample(Csound self, int channel, int frame, double sample) -> int"""
        return _csnd.Csound_ChanIASetSample(self, *args)

    def ChanOAGetSample(self, *args):
        """ChanOAGetSample(Csound self, int channel, int frame) -> double"""
        return _csnd.Csound_ChanOAGetSample(self, *args)

    def SetHostData(self, *args):
        """SetHostData(Csound self, PyObject * data)"""
        return _csnd.Csound_SetHostData(self, *args)

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

    def SetInputValueCallback(self, *args):
        """SetInputValueCallback(Csound self, PyObject * pyfunc)"""
        return _csnd.Csound_SetInputValueCallback(self, *args)

    def SetOutputValueCallback(self, *args):
        """SetOutputValueCallback(Csound self, PyObject * pyfunc)"""
        return _csnd.Csound_SetOutputValueCallback(self, *args)

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

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

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundThreadLock self) -> CsoundThreadLock
        __init__(CsoundThreadLock 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(CsoundMutex self)"""
        return _csnd.CsoundMutex_Lock(self)

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundMutex self) -> CsoundMutex
        __init__(CsoundMutex 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(CsoundRandMT self) -> uint32_t"""
        return _csnd.CsoundRandMT_Random(self)

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

    def __init__(self, *args): 
        """
        __init__(CsoundRandMT self) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t seedVal) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t const * initKey, int keyLength) -> CsoundRandMT
        """
        this = _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(CsoundTimer self) -> double"""
        return _csnd.CsoundTimer_GetRealTime(self)

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

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

    def __init__(self): 
        """__init__(CsoundTimer 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(CsoundOpcodeList self) -> int"""
        return _csnd.CsoundOpcodeList_Count(self)

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundOpcodeList self, CSOUND * csound) -> CsoundOpcodeList
        __init__(CsoundOpcodeList 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(CsoundChannelList self) -> int"""
        return _csnd.CsoundChannelList_Count(self)

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundChannelList self, CSOUND * csound) -> CsoundChannelList
        __init__(CsoundChannelList 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(CsoundUtilityList self) -> int"""
        return _csnd.CsoundUtilityList_Count(self)

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundUtilityList self, CSOUND * csound) -> CsoundUtilityList
        __init__(CsoundUtilityList 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(CsoundMYFLTArray self) -> double
        GetPtr(CsoundMYFLTArray self, int ndx) -> double *
        """
        return _csnd.CsoundMYFLTArray_GetPtr(self, *args)

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

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

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

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

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundMYFLTArray self) -> CsoundMYFLTArray
        __init__(CsoundMYFLTArray 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(CsoundArgVList self) -> int"""
        return _csnd.CsoundArgVList_argc(self)

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

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

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

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

    def __init__(self): 
        """__init__(CsoundArgVList 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(CsoundCallbackWrapper self, int attr, char * msg)"""
        return _csnd.CsoundCallbackWrapper_MessageCallback(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:CharPtrToString = staticmethod(CharPtrToString)
    __swig_getmethods__["CharPtrToString"] = lambda x: CharPtrToString
    def __init__(self, *args): 
        """
        __init__(CsoundCallbackWrapper self, Csound csound) -> CsoundCallbackWrapper
        __init__(CsoundCallbackWrapper self, CSOUND * csound) -> CsoundCallbackWrapper
        """
        if self.__class__ == CsoundCallbackWrapper:
            _self = None
        else:
            _self = self
        this = _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 const * s) -> char const *"""
  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__(CsoundMidiInputBuffer 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(CsoundMidiInputBuffer self, int msg)
        SendMessage(CsoundMidiInputBuffer self, int status, int channel, int data1, int data2)
        """
        return _csnd.CsoundMidiInputBuffer_SendMessage(self, *args)

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

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

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

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

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

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

    def SendPitchBend(self, *args):
        """SendPitchBend(CsoundMidiInputBuffer 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__(CsoundMidiInputStream self, CSOUND * csound) -> CsoundMidiInputStream
        __init__(CsoundMidiInputStream 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(CsoundMidiInputStream 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__(CsoundMidiOutputBuffer 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(CsoundMidiOutputBuffer self) -> int"""
        return _csnd.CsoundMidiOutputBuffer_PopMessage(self)

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

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

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

    def GetData2(self):
        """GetData2(CsoundMidiOutputBuffer 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__(CsoundMidiOutputStream self, CSOUND * csound) -> CsoundMidiOutputStream
        __init__(CsoundMidiOutputStream 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(CsoundMidiOutputStream 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__(pycallbackdata 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
    def isRunning(self):
        """isRunning(CsoundPerformanceThread self) -> int"""
        return _csnd.CsoundPerformanceThread_isRunning(self)

    __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(CsoundPerformanceThread self) -> void *"""
        return _csnd.CsoundPerformanceThread_GetProcessCallback(self)

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(CsoundPerformanceThread self, Csound arg2) -> CsoundPerformanceThread
        __init__(CsoundPerformanceThread self, CSOUND * arg2) -> 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(CsoundPerformanceThread 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(IntToStringMap self) -> SwigPyIterator"""
        return _csnd.IntToStringMap_iterator(self)

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

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

    def __len__(self):
        """__len__(IntToStringMap self) -> std::map< int,std::string >::size_type"""
        return _csnd.IntToStringMap___len__(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args):
        """__getitem__(IntToStringMap self, std::map< int,std::string >::key_type const & key) -> std::map< int,std::string >::mapped_type const &"""
        return _csnd.IntToStringMap___getitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def upper_bound(self, *args):
        """upper_bound(IntToStringMap self, std::map< int,std::string >::key_type const & x) -> std::map< int,std::string >::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 const ** argv, std::string & commandLine)"""
  return _csnd.gatherArgs(*args)

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

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

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

def parseInstrument(*args):
  """
    parseInstrument(std::string const & definition, std::string & preNumber, std::string & id, std::string & name, 
        std::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__(CsoundFile 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(CsoundFile self) -> std::string"""
        return _csnd.CsoundFile_generateFilename(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CsoundFile_swigregister = _csnd.CsoundFile_swigregister
CsoundFile_swigregister(CsoundFile)

class MyfltVector(_object):
    """Proxy of C++ std::vector<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MyfltVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MyfltVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(MyfltVector self) -> SwigPyIterator"""
        return _csnd.MyfltVector_iterator(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args): 
        """
        __init__(std::vector<(double)> self) -> MyfltVector
        __init__(std::vector<(double)> self, MyfltVector arg2) -> MyfltVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> MyfltVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> MyfltVector
        """
        this = _csnd.new_MyfltVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(MyfltVector self, std::vector< double >::value_type const & x)"""
        return _csnd.MyfltVector_push_back(self, *args)

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

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

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

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

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

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

    def capacity(self):
        """capacity(MyfltVector self) -> std::vector< double >::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__(CppSound 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(CppSound self) -> CSOUND *"""
        return _csnd.CppSound_getCsound(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CppSound_swigregister = _csnd.CppSound_swigregister
CppSound_swigregister(CppSound)

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


