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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError('Python 2.7 or later required')

# Import the low-level C/C++ module
if __package__ or '.' in __name__:
    from . import _csnd6
else:
    import _csnd6

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if name == "thisown":
        return self.this.own(value)
    if name == "this":
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if not static:
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if name == "thisown":
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _csnd6:
_csnd6.SwigPyIterator_swigregister(SwigPyIterator)


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

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

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

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

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

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

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

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

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

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

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

def doublep_setitem(ary, index, value):
    return _csnd6.doublep_setitem(ary, index, value)
class intArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _csnd6.intArray_swiginit(self, _csnd6.new_intArray(nelements))
    __swig_destroy__ = _csnd6.delete_intArray

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

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

    def cast(self):
        return _csnd6.intArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _csnd6.intArray_frompointer(t)

# Register intArray in _csnd6:
_csnd6.intArray_swigregister(intArray)

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

class floatArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _csnd6.floatArray_swiginit(self, _csnd6.new_floatArray(nelements))
    __swig_destroy__ = _csnd6.delete_floatArray

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

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

    def cast(self):
        return _csnd6.floatArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _csnd6.floatArray_frompointer(t)

# Register floatArray in _csnd6:
_csnd6.floatArray_swigregister(floatArray)

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

class doubleArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _csnd6.doubleArray_swiginit(self, _csnd6.new_doubleArray(nelements))
    __swig_destroy__ = _csnd6.delete_doubleArray

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

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

    def cast(self):
        return _csnd6.doubleArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _csnd6.doubleArray_frompointer(t)

# Register doubleArray in _csnd6:
_csnd6.doubleArray_swigregister(doubleArray)

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

CSOUND_SUCCESS = _csnd6.CSOUND_SUCCESS

CSOUND_ERROR = _csnd6.CSOUND_ERROR

CSOUND_INITIALIZATION = _csnd6.CSOUND_INITIALIZATION

CSOUND_PERFORMANCE = _csnd6.CSOUND_PERFORMANCE

CSOUND_MEMORY = _csnd6.CSOUND_MEMORY

CSOUND_SIGNAL = _csnd6.CSOUND_SIGNAL

CSOUND_EXITJMP_SUCCESS = _csnd6.CSOUND_EXITJMP_SUCCESS

CSOUNDINIT_NO_SIGNAL_HANDLER = _csnd6.CSOUNDINIT_NO_SIGNAL_HANDLER

CSOUNDINIT_NO_ATEXIT = _csnd6.CSOUNDINIT_NO_ATEXIT

CSOUND_CALLBACK_KBD_EVENT = _csnd6.CSOUND_CALLBACK_KBD_EVENT

CSOUND_CALLBACK_KBD_TEXT = _csnd6.CSOUND_CALLBACK_KBD_TEXT

CSFTYPE_UNIFIED_CSD = _csnd6.CSFTYPE_UNIFIED_CSD

CSFTYPE_ORCHESTRA = _csnd6.CSFTYPE_ORCHESTRA

CSFTYPE_SCORE = _csnd6.CSFTYPE_SCORE

CSFTYPE_ORC_INCLUDE = _csnd6.CSFTYPE_ORC_INCLUDE

CSFTYPE_SCO_INCLUDE = _csnd6.CSFTYPE_SCO_INCLUDE

CSFTYPE_SCORE_OUT = _csnd6.CSFTYPE_SCORE_OUT

CSFTYPE_SCOT = _csnd6.CSFTYPE_SCOT

CSFTYPE_OPTIONS = _csnd6.CSFTYPE_OPTIONS

CSFTYPE_EXTRACT_PARMS = _csnd6.CSFTYPE_EXTRACT_PARMS

CSFTYPE_RAW_AUDIO = _csnd6.CSFTYPE_RAW_AUDIO

CSFTYPE_IRCAM = _csnd6.CSFTYPE_IRCAM

CSFTYPE_AIFF = _csnd6.CSFTYPE_AIFF

CSFTYPE_AIFC = _csnd6.CSFTYPE_AIFC

CSFTYPE_WAVE = _csnd6.CSFTYPE_WAVE

CSFTYPE_AU = _csnd6.CSFTYPE_AU

CSFTYPE_SD2 = _csnd6.CSFTYPE_SD2

CSFTYPE_W64 = _csnd6.CSFTYPE_W64

CSFTYPE_WAVEX = _csnd6.CSFTYPE_WAVEX

CSFTYPE_FLAC = _csnd6.CSFTYPE_FLAC

CSFTYPE_CAF = _csnd6.CSFTYPE_CAF

CSFTYPE_WVE = _csnd6.CSFTYPE_WVE

CSFTYPE_OGG = _csnd6.CSFTYPE_OGG

CSFTYPE_MPC2K = _csnd6.CSFTYPE_MPC2K

CSFTYPE_RF64 = _csnd6.CSFTYPE_RF64

CSFTYPE_AVR = _csnd6.CSFTYPE_AVR

CSFTYPE_HTK = _csnd6.CSFTYPE_HTK

CSFTYPE_MAT4 = _csnd6.CSFTYPE_MAT4

CSFTYPE_MAT5 = _csnd6.CSFTYPE_MAT5

CSFTYPE_NIST = _csnd6.CSFTYPE_NIST

CSFTYPE_PAF = _csnd6.CSFTYPE_PAF

CSFTYPE_PVF = _csnd6.CSFTYPE_PVF

CSFTYPE_SDS = _csnd6.CSFTYPE_SDS

CSFTYPE_SVX = _csnd6.CSFTYPE_SVX

CSFTYPE_VOC = _csnd6.CSFTYPE_VOC

CSFTYPE_XI = _csnd6.CSFTYPE_XI

CSFTYPE_UNKNOWN_AUDIO = _csnd6.CSFTYPE_UNKNOWN_AUDIO

CSFTYPE_SOUNDFONT = _csnd6.CSFTYPE_SOUNDFONT

CSFTYPE_STD_MIDI = _csnd6.CSFTYPE_STD_MIDI

CSFTYPE_MIDI_SYSEX = _csnd6.CSFTYPE_MIDI_SYSEX

CSFTYPE_HETRO = _csnd6.CSFTYPE_HETRO

CSFTYPE_HETROT = _csnd6.CSFTYPE_HETROT

CSFTYPE_PVC = _csnd6.CSFTYPE_PVC

CSFTYPE_PVCEX = _csnd6.CSFTYPE_PVCEX

CSFTYPE_CVANAL = _csnd6.CSFTYPE_CVANAL

CSFTYPE_LPC = _csnd6.CSFTYPE_LPC

CSFTYPE_ATS = _csnd6.CSFTYPE_ATS

CSFTYPE_LORIS = _csnd6.CSFTYPE_LORIS

CSFTYPE_SDIF = _csnd6.CSFTYPE_SDIF

CSFTYPE_HRTF = _csnd6.CSFTYPE_HRTF

CSFTYPE_UNUSED = _csnd6.CSFTYPE_UNUSED

CSFTYPE_LADSPA_PLUGIN = _csnd6.CSFTYPE_LADSPA_PLUGIN

CSFTYPE_SNAPSHOT = _csnd6.CSFTYPE_SNAPSHOT

CSFTYPE_FTABLES_TEXT = _csnd6.CSFTYPE_FTABLES_TEXT

CSFTYPE_FTABLES_BINARY = _csnd6.CSFTYPE_FTABLES_BINARY

CSFTYPE_XSCANU_MATRIX = _csnd6.CSFTYPE_XSCANU_MATRIX

CSFTYPE_FLOATS_TEXT = _csnd6.CSFTYPE_FLOATS_TEXT

CSFTYPE_FLOATS_BINARY = _csnd6.CSFTYPE_FLOATS_BINARY

CSFTYPE_INTEGER_TEXT = _csnd6.CSFTYPE_INTEGER_TEXT

CSFTYPE_INTEGER_BINARY = _csnd6.CSFTYPE_INTEGER_BINARY

CSFTYPE_IMAGE_PNG = _csnd6.CSFTYPE_IMAGE_PNG

CSFTYPE_POSTSCRIPT = _csnd6.CSFTYPE_POSTSCRIPT

CSFTYPE_SCRIPT_TEXT = _csnd6.CSFTYPE_SCRIPT_TEXT

CSFTYPE_OTHER_TEXT = _csnd6.CSFTYPE_OTHER_TEXT

CSFTYPE_OTHER_BINARY = _csnd6.CSFTYPE_OTHER_BINARY

CSFTYPE_UNKNOWN = _csnd6.CSFTYPE_UNKNOWN

class CSOUND_PARAMS(object):
    r"""Proxy of C++ CSOUND_PARAMS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    debug_mode = property(_csnd6.CSOUND_PARAMS_debug_mode_get, _csnd6.CSOUND_PARAMS_debug_mode_set, doc=r"""debug_mode : int""")
    buffer_frames = property(_csnd6.CSOUND_PARAMS_buffer_frames_get, _csnd6.CSOUND_PARAMS_buffer_frames_set, doc=r"""buffer_frames : int""")
    hardware_buffer_frames = property(_csnd6.CSOUND_PARAMS_hardware_buffer_frames_get, _csnd6.CSOUND_PARAMS_hardware_buffer_frames_set, doc=r"""hardware_buffer_frames : int""")
    displays = property(_csnd6.CSOUND_PARAMS_displays_get, _csnd6.CSOUND_PARAMS_displays_set, doc=r"""displays : int""")
    ascii_graphs = property(_csnd6.CSOUND_PARAMS_ascii_graphs_get, _csnd6.CSOUND_PARAMS_ascii_graphs_set, doc=r"""ascii_graphs : int""")
    postscript_graphs = property(_csnd6.CSOUND_PARAMS_postscript_graphs_get, _csnd6.CSOUND_PARAMS_postscript_graphs_set, doc=r"""postscript_graphs : int""")
    message_level = property(_csnd6.CSOUND_PARAMS_message_level_get, _csnd6.CSOUND_PARAMS_message_level_set, doc=r"""message_level : int""")
    tempo = property(_csnd6.CSOUND_PARAMS_tempo_get, _csnd6.CSOUND_PARAMS_tempo_set, doc=r"""tempo : int""")
    ring_bell = property(_csnd6.CSOUND_PARAMS_ring_bell_get, _csnd6.CSOUND_PARAMS_ring_bell_set, doc=r"""ring_bell : int""")
    use_cscore = property(_csnd6.CSOUND_PARAMS_use_cscore_get, _csnd6.CSOUND_PARAMS_use_cscore_set, doc=r"""use_cscore : int""")
    terminate_on_midi = property(_csnd6.CSOUND_PARAMS_terminate_on_midi_get, _csnd6.CSOUND_PARAMS_terminate_on_midi_set, doc=r"""terminate_on_midi : int""")
    heartbeat = property(_csnd6.CSOUND_PARAMS_heartbeat_get, _csnd6.CSOUND_PARAMS_heartbeat_set, doc=r"""heartbeat : int""")
    defer_gen01_load = property(_csnd6.CSOUND_PARAMS_defer_gen01_load_get, _csnd6.CSOUND_PARAMS_defer_gen01_load_set, doc=r"""defer_gen01_load : int""")
    midi_key = property(_csnd6.CSOUND_PARAMS_midi_key_get, _csnd6.CSOUND_PARAMS_midi_key_set, doc=r"""midi_key : int""")
    midi_key_cps = property(_csnd6.CSOUND_PARAMS_midi_key_cps_get, _csnd6.CSOUND_PARAMS_midi_key_cps_set, doc=r"""midi_key_cps : int""")
    midi_key_oct = property(_csnd6.CSOUND_PARAMS_midi_key_oct_get, _csnd6.CSOUND_PARAMS_midi_key_oct_set, doc=r"""midi_key_oct : int""")
    midi_key_pch = property(_csnd6.CSOUND_PARAMS_midi_key_pch_get, _csnd6.CSOUND_PARAMS_midi_key_pch_set, doc=r"""midi_key_pch : int""")
    midi_velocity = property(_csnd6.CSOUND_PARAMS_midi_velocity_get, _csnd6.CSOUND_PARAMS_midi_velocity_set, doc=r"""midi_velocity : int""")
    midi_velocity_amp = property(_csnd6.CSOUND_PARAMS_midi_velocity_amp_get, _csnd6.CSOUND_PARAMS_midi_velocity_amp_set, doc=r"""midi_velocity_amp : int""")
    no_default_paths = property(_csnd6.CSOUND_PARAMS_no_default_paths_get, _csnd6.CSOUND_PARAMS_no_default_paths_set, doc=r"""no_default_paths : int""")
    number_of_threads = property(_csnd6.CSOUND_PARAMS_number_of_threads_get, _csnd6.CSOUND_PARAMS_number_of_threads_set, doc=r"""number_of_threads : int""")
    syntax_check_only = property(_csnd6.CSOUND_PARAMS_syntax_check_only_get, _csnd6.CSOUND_PARAMS_syntax_check_only_set, doc=r"""syntax_check_only : int""")
    csd_line_counts = property(_csnd6.CSOUND_PARAMS_csd_line_counts_get, _csnd6.CSOUND_PARAMS_csd_line_counts_set, doc=r"""csd_line_counts : int""")
    compute_weights = property(_csnd6.CSOUND_PARAMS_compute_weights_get, _csnd6.CSOUND_PARAMS_compute_weights_set, doc=r"""compute_weights : int""")
    realtime_mode = property(_csnd6.CSOUND_PARAMS_realtime_mode_get, _csnd6.CSOUND_PARAMS_realtime_mode_set, doc=r"""realtime_mode : int""")
    sample_accurate = property(_csnd6.CSOUND_PARAMS_sample_accurate_get, _csnd6.CSOUND_PARAMS_sample_accurate_set, doc=r"""sample_accurate : int""")
    sample_rate_override = property(_csnd6.CSOUND_PARAMS_sample_rate_override_get, _csnd6.CSOUND_PARAMS_sample_rate_override_set, doc=r"""sample_rate_override : double""")
    control_rate_override = property(_csnd6.CSOUND_PARAMS_control_rate_override_get, _csnd6.CSOUND_PARAMS_control_rate_override_set, doc=r"""control_rate_override : double""")
    nchnls_override = property(_csnd6.CSOUND_PARAMS_nchnls_override_get, _csnd6.CSOUND_PARAMS_nchnls_override_set, doc=r"""nchnls_override : int""")
    nchnls_i_override = property(_csnd6.CSOUND_PARAMS_nchnls_i_override_get, _csnd6.CSOUND_PARAMS_nchnls_i_override_set, doc=r"""nchnls_i_override : int""")
    e0dbfs_override = property(_csnd6.CSOUND_PARAMS_e0dbfs_override_get, _csnd6.CSOUND_PARAMS_e0dbfs_override_set, doc=r"""e0dbfs_override : double""")
    daemon = property(_csnd6.CSOUND_PARAMS_daemon_get, _csnd6.CSOUND_PARAMS_daemon_set, doc=r"""daemon : int""")
    ksmps_override = property(_csnd6.CSOUND_PARAMS_ksmps_override_get, _csnd6.CSOUND_PARAMS_ksmps_override_set, doc=r"""ksmps_override : int""")
    FFT_library = property(_csnd6.CSOUND_PARAMS_FFT_library_get, _csnd6.CSOUND_PARAMS_FFT_library_set, doc=r"""FFT_library : int""")

    def __init__(self):
        r"""__init__(CSOUND_PARAMS self) -> CSOUND_PARAMS"""
        _csnd6.CSOUND_PARAMS_swiginit(self, _csnd6.new_CSOUND_PARAMS())
    __swig_destroy__ = _csnd6.delete_CSOUND_PARAMS

# Register CSOUND_PARAMS in _csnd6:
_csnd6.CSOUND_PARAMS_swigregister(CSOUND_PARAMS)

class CS_AUDIODEVICE(object):
    r"""Proxy of C++ CS_AUDIODEVICE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    device_name = property(_csnd6.CS_AUDIODEVICE_device_name_get, _csnd6.CS_AUDIODEVICE_device_name_set, doc=r"""device_name : a(64).char""")
    device_id = property(_csnd6.CS_AUDIODEVICE_device_id_get, _csnd6.CS_AUDIODEVICE_device_id_set, doc=r"""device_id : a(64).char""")
    rt_module = property(_csnd6.CS_AUDIODEVICE_rt_module_get, _csnd6.CS_AUDIODEVICE_rt_module_set, doc=r"""rt_module : a(64).char""")
    max_nchnls = property(_csnd6.CS_AUDIODEVICE_max_nchnls_get, _csnd6.CS_AUDIODEVICE_max_nchnls_set, doc=r"""max_nchnls : int""")
    isOutput = property(_csnd6.CS_AUDIODEVICE_isOutput_get, _csnd6.CS_AUDIODEVICE_isOutput_set, doc=r"""isOutput : int""")

    def __init__(self):
        r"""__init__(CS_AUDIODEVICE self) -> CS_AUDIODEVICE"""
        _csnd6.CS_AUDIODEVICE_swiginit(self, _csnd6.new_CS_AUDIODEVICE())
    __swig_destroy__ = _csnd6.delete_CS_AUDIODEVICE

# Register CS_AUDIODEVICE in _csnd6:
_csnd6.CS_AUDIODEVICE_swigregister(CS_AUDIODEVICE)

class CS_MIDIDEVICE(object):
    r"""Proxy of C++ CS_MIDIDEVICE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    device_name = property(_csnd6.CS_MIDIDEVICE_device_name_get, _csnd6.CS_MIDIDEVICE_device_name_set, doc=r"""device_name : a(64).char""")
    interface_name = property(_csnd6.CS_MIDIDEVICE_interface_name_get, _csnd6.CS_MIDIDEVICE_interface_name_set, doc=r"""interface_name : a(64).char""")
    device_id = property(_csnd6.CS_MIDIDEVICE_device_id_get, _csnd6.CS_MIDIDEVICE_device_id_set, doc=r"""device_id : a(64).char""")
    midi_module = property(_csnd6.CS_MIDIDEVICE_midi_module_get, _csnd6.CS_MIDIDEVICE_midi_module_set, doc=r"""midi_module : a(64).char""")
    isOutput = property(_csnd6.CS_MIDIDEVICE_isOutput_get, _csnd6.CS_MIDIDEVICE_isOutput_set, doc=r"""isOutput : int""")

    def __init__(self):
        r"""__init__(CS_MIDIDEVICE self) -> CS_MIDIDEVICE"""
        _csnd6.CS_MIDIDEVICE_swiginit(self, _csnd6.new_CS_MIDIDEVICE())
    __swig_destroy__ = _csnd6.delete_CS_MIDIDEVICE

# Register CS_MIDIDEVICE in _csnd6:
_csnd6.CS_MIDIDEVICE_swigregister(CS_MIDIDEVICE)

class csRtAudioParams(object):
    r"""Proxy of C++ csRtAudioParams class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    devName = property(_csnd6.csRtAudioParams_devName_get, _csnd6.csRtAudioParams_devName_set, doc=r"""devName : p.char""")
    devNum = property(_csnd6.csRtAudioParams_devNum_get, _csnd6.csRtAudioParams_devNum_set, doc=r"""devNum : int""")
    bufSamp_SW = property(_csnd6.csRtAudioParams_bufSamp_SW_get, _csnd6.csRtAudioParams_bufSamp_SW_set, doc=r"""bufSamp_SW : unsigned int""")
    bufSamp_HW = property(_csnd6.csRtAudioParams_bufSamp_HW_get, _csnd6.csRtAudioParams_bufSamp_HW_set, doc=r"""bufSamp_HW : int""")
    nChannels = property(_csnd6.csRtAudioParams_nChannels_get, _csnd6.csRtAudioParams_nChannels_set, doc=r"""nChannels : int""")
    sampleFormat = property(_csnd6.csRtAudioParams_sampleFormat_get, _csnd6.csRtAudioParams_sampleFormat_set, doc=r"""sampleFormat : int""")
    sampleRate = property(_csnd6.csRtAudioParams_sampleRate_get, _csnd6.csRtAudioParams_sampleRate_set, doc=r"""sampleRate : float""")

    def __init__(self):
        r"""__init__(csRtAudioParams self) -> csRtAudioParams"""
        _csnd6.csRtAudioParams_swiginit(self, _csnd6.new_csRtAudioParams())
    __swig_destroy__ = _csnd6.delete_csRtAudioParams

# Register csRtAudioParams in _csnd6:
_csnd6.csRtAudioParams_swigregister(csRtAudioParams)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    starttime_real = property(_csnd6.RTCLOCK_starttime_real_get, _csnd6.RTCLOCK_starttime_real_set, doc=r"""starttime_real : int_least64_t""")
    starttime_CPU = property(_csnd6.RTCLOCK_starttime_CPU_get, _csnd6.RTCLOCK_starttime_CPU_set, doc=r"""starttime_CPU : int_least64_t""")

    def __init__(self):
        r"""__init__(RTCLOCK self) -> RTCLOCK"""
        _csnd6.RTCLOCK_swiginit(self, _csnd6.new_RTCLOCK())
    __swig_destroy__ = _csnd6.delete_RTCLOCK

# Register RTCLOCK in _csnd6:
_csnd6.RTCLOCK_swigregister(RTCLOCK)

class opcodeListEntry(object):
    r"""Proxy of C++ opcodeListEntry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    opname = property(_csnd6.opcodeListEntry_opname_get, _csnd6.opcodeListEntry_opname_set, doc=r"""opname : p.char""")
    outypes = property(_csnd6.opcodeListEntry_outypes_get, _csnd6.opcodeListEntry_outypes_set, doc=r"""outypes : p.char""")
    intypes = property(_csnd6.opcodeListEntry_intypes_get, _csnd6.opcodeListEntry_intypes_set, doc=r"""intypes : p.char""")
    flags = property(_csnd6.opcodeListEntry_flags_get, _csnd6.opcodeListEntry_flags_set, doc=r"""flags : int""")

    def __init__(self):
        r"""__init__(opcodeListEntry self) -> opcodeListEntry"""
        _csnd6.opcodeListEntry_swiginit(self, _csnd6.new_opcodeListEntry())
    __swig_destroy__ = _csnd6.delete_opcodeListEntry

# Register opcodeListEntry in _csnd6:
_csnd6.opcodeListEntry_swigregister(opcodeListEntry)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mti = property(_csnd6.CsoundRandMTState_mti_get, _csnd6.CsoundRandMTState_mti_set, doc=r"""mti : int""")
    mt = property(_csnd6.CsoundRandMTState_mt_get, _csnd6.CsoundRandMTState_mt_set, doc=r"""mt : a(624).uint32_t""")

    def __init__(self):
        r"""__init__(CsoundRandMTState self) -> CsoundRandMTState"""
        _csnd6.CsoundRandMTState_swiginit(self, _csnd6.new_CsoundRandMTState())
    __swig_destroy__ = _csnd6.delete_CsoundRandMTState

# Register CsoundRandMTState in _csnd6:
_csnd6.CsoundRandMTState_swigregister(CsoundRandMTState)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    N = property(_csnd6.PVSDATEXT_N_get, _csnd6.PVSDATEXT_N_set, doc=r"""N : int32""")
    sliding = property(_csnd6.PVSDATEXT_sliding_get, _csnd6.PVSDATEXT_sliding_set, doc=r"""sliding : int""")
    NB = property(_csnd6.PVSDATEXT_NB_get, _csnd6.PVSDATEXT_NB_set, doc=r"""NB : int32""")
    overlap = property(_csnd6.PVSDATEXT_overlap_get, _csnd6.PVSDATEXT_overlap_set, doc=r"""overlap : int32""")
    winsize = property(_csnd6.PVSDATEXT_winsize_get, _csnd6.PVSDATEXT_winsize_set, doc=r"""winsize : int32""")
    wintype = property(_csnd6.PVSDATEXT_wintype_get, _csnd6.PVSDATEXT_wintype_set, doc=r"""wintype : int""")
    format = property(_csnd6.PVSDATEXT_format_get, _csnd6.PVSDATEXT_format_set, doc=r"""format : int32""")
    framecount = property(_csnd6.PVSDATEXT_framecount_get, _csnd6.PVSDATEXT_framecount_set, doc=r"""framecount : uint32""")
    frame = property(_csnd6.PVSDATEXT_frame_get, _csnd6.PVSDATEXT_frame_set, doc=r"""frame : p.float""")

    def __init__(self):
        r"""__init__(PVSDATEXT self) -> PVSDATEXT"""
        _csnd6.PVSDATEXT_swiginit(self, _csnd6.new_PVSDATEXT())
    __swig_destroy__ = _csnd6.delete_PVSDATEXT

# Register PVSDATEXT in _csnd6:
_csnd6.PVSDATEXT_swigregister(PVSDATEXT)

class ORCTOKEN(object):
    r"""Proxy of C++ ORCTOKEN class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = property(_csnd6.ORCTOKEN_type_get, _csnd6.ORCTOKEN_type_set, doc=r"""type : int""")
    lexeme = property(_csnd6.ORCTOKEN_lexeme_get, _csnd6.ORCTOKEN_lexeme_set, doc=r"""lexeme : p.char""")
    value = property(_csnd6.ORCTOKEN_value_get, _csnd6.ORCTOKEN_value_set, doc=r"""value : int""")
    fvalue = property(_csnd6.ORCTOKEN_fvalue_get, _csnd6.ORCTOKEN_fvalue_set, doc=r"""fvalue : double""")
    optype = property(_csnd6.ORCTOKEN_optype_get, _csnd6.ORCTOKEN_optype_set, doc=r"""optype : p.char""")
    next = property(_csnd6.ORCTOKEN_next_get, _csnd6.ORCTOKEN_next_set, doc=r"""next : p.ORCTOKEN""")

    def __init__(self):
        r"""__init__(ORCTOKEN self) -> ORCTOKEN"""
        _csnd6.ORCTOKEN_swiginit(self, _csnd6.new_ORCTOKEN())
    __swig_destroy__ = _csnd6.delete_ORCTOKEN

# Register ORCTOKEN in _csnd6:
_csnd6.ORCTOKEN_swigregister(ORCTOKEN)

class TREE(object):
    r"""Proxy of C++ TREE class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    type = property(_csnd6.TREE_type_get, _csnd6.TREE_type_set, doc=r"""type : int""")
    value = property(_csnd6.TREE_value_get, _csnd6.TREE_value_set, doc=r"""value : p.ORCTOKEN""")
    rate = property(_csnd6.TREE_rate_get, _csnd6.TREE_rate_set, doc=r"""rate : int""")
    len = property(_csnd6.TREE_len_get, _csnd6.TREE_len_set, doc=r"""len : int""")
    line = property(_csnd6.TREE_line_get, _csnd6.TREE_line_set, doc=r"""line : int""")
    locn = property(_csnd6.TREE_locn_get, _csnd6.TREE_locn_set, doc=r"""locn : uint64_t""")
    left = property(_csnd6.TREE_left_get, _csnd6.TREE_left_set, doc=r"""left : p.TREE""")
    right = property(_csnd6.TREE_right_get, _csnd6.TREE_right_set, doc=r"""right : p.TREE""")
    next = property(_csnd6.TREE_next_get, _csnd6.TREE_next_set, doc=r"""next : p.TREE""")
    markup = property(_csnd6.TREE_markup_get, _csnd6.TREE_markup_set, doc=r"""markup : p.void""")

    def __init__(self):
        r"""__init__(TREE self) -> TREE"""
        _csnd6.TREE_swiginit(self, _csnd6.new_TREE())
    __swig_destroy__ = _csnd6.delete_TREE

# Register TREE in _csnd6:
_csnd6.TREE_swigregister(TREE)

CSOUND_CONTROL_CHANNEL = _csnd6.CSOUND_CONTROL_CHANNEL

CSOUND_AUDIO_CHANNEL = _csnd6.CSOUND_AUDIO_CHANNEL

CSOUND_STRING_CHANNEL = _csnd6.CSOUND_STRING_CHANNEL

CSOUND_PVS_CHANNEL = _csnd6.CSOUND_PVS_CHANNEL

CSOUND_VAR_CHANNEL = _csnd6.CSOUND_VAR_CHANNEL

CSOUND_CHANNEL_TYPE_MASK = _csnd6.CSOUND_CHANNEL_TYPE_MASK

CSOUND_INPUT_CHANNEL = _csnd6.CSOUND_INPUT_CHANNEL

CSOUND_OUTPUT_CHANNEL = _csnd6.CSOUND_OUTPUT_CHANNEL

CSOUND_CONTROL_CHANNEL_NO_HINTS = _csnd6.CSOUND_CONTROL_CHANNEL_NO_HINTS

CSOUND_CONTROL_CHANNEL_INT = _csnd6.CSOUND_CONTROL_CHANNEL_INT

CSOUND_CONTROL_CHANNEL_LIN = _csnd6.CSOUND_CONTROL_CHANNEL_LIN

CSOUND_CONTROL_CHANNEL_EXP = _csnd6.CSOUND_CONTROL_CHANNEL_EXP

class controlChannelHints_t(object):
    r"""Proxy of C++ controlChannelHints_s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    behav = property(_csnd6.controlChannelHints_t_behav_get, _csnd6.controlChannelHints_t_behav_set, doc=r"""behav : controlChannelBehavior""")
    dflt = property(_csnd6.controlChannelHints_t_dflt_get, _csnd6.controlChannelHints_t_dflt_set, doc=r"""dflt : double""")
    min = property(_csnd6.controlChannelHints_t_min_get, _csnd6.controlChannelHints_t_min_set, doc=r"""min : double""")
    max = property(_csnd6.controlChannelHints_t_max_get, _csnd6.controlChannelHints_t_max_set, doc=r"""max : double""")
    x = property(_csnd6.controlChannelHints_t_x_get, _csnd6.controlChannelHints_t_x_set, doc=r"""x : int""")
    y = property(_csnd6.controlChannelHints_t_y_get, _csnd6.controlChannelHints_t_y_set, doc=r"""y : int""")
    width = property(_csnd6.controlChannelHints_t_width_get, _csnd6.controlChannelHints_t_width_set, doc=r"""width : int""")
    height = property(_csnd6.controlChannelHints_t_height_get, _csnd6.controlChannelHints_t_height_set, doc=r"""height : int""")
    attributes = property(_csnd6.controlChannelHints_t_attributes_get, _csnd6.controlChannelHints_t_attributes_set, doc=r"""attributes : p.char""")

    def __init__(self):
        r"""__init__(controlChannelHints_t self) -> controlChannelHints_t"""
        _csnd6.controlChannelHints_t_swiginit(self, _csnd6.new_controlChannelHints_t())
    __swig_destroy__ = _csnd6.delete_controlChannelHints_t

# Register controlChannelHints_t in _csnd6:
_csnd6.controlChannelHints_t_swigregister(controlChannelHints_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    name = property(_csnd6.controlChannelInfo_t_name_get, _csnd6.controlChannelInfo_t_name_set, doc=r"""name : p.char""")
    type = property(_csnd6.controlChannelInfo_t_type_get, _csnd6.controlChannelInfo_t_type_set, doc=r"""type : int""")
    hints = property(_csnd6.controlChannelInfo_t_hints_get, _csnd6.controlChannelInfo_t_hints_set, doc=r"""hints : controlChannelHints_t""")

    def __init__(self):
        r"""__init__(controlChannelInfo_t self) -> controlChannelInfo_t"""
        _csnd6.controlChannelInfo_t_swiginit(self, _csnd6.new_controlChannelInfo_t())
    __swig_destroy__ = _csnd6.delete_controlChannelInfo_t

# Register controlChannelInfo_t in _csnd6:
_csnd6.controlChannelInfo_t_swigregister(controlChannelInfo_t)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def csoundSystemSr(csound, val):
    r"""csoundSystemSr(CSOUND * csound, double val) -> double"""
    return _csnd6.csoundSystemSr(csound, val)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableHead_t_nxt_get, _csnd6.csCfgVariableHead_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableHead_t_name_get, _csnd6.csCfgVariableHead_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableHead_t_p_get, _csnd6.csCfgVariableHead_t_p_set, doc=r"""p : p.void""")
    type = property(_csnd6.csCfgVariableHead_t_type_get, _csnd6.csCfgVariableHead_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableHead_t_flags_get, _csnd6.csCfgVariableHead_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableHead_t_shortDesc_get, _csnd6.csCfgVariableHead_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableHead_t_longDesc_get, _csnd6.csCfgVariableHead_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")

    def __init__(self):
        r"""__init__(csCfgVariableHead_t self) -> csCfgVariableHead_t"""
        _csnd6.csCfgVariableHead_t_swiginit(self, _csnd6.new_csCfgVariableHead_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableHead_t

# Register csCfgVariableHead_t in _csnd6:
_csnd6.csCfgVariableHead_t_swigregister(csCfgVariableHead_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableInt_t_nxt_get, _csnd6.csCfgVariableInt_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableInt_t_name_get, _csnd6.csCfgVariableInt_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableInt_t_p_get, _csnd6.csCfgVariableInt_t_p_set, doc=r"""p : p.int""")
    type = property(_csnd6.csCfgVariableInt_t_type_get, _csnd6.csCfgVariableInt_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableInt_t_flags_get, _csnd6.csCfgVariableInt_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableInt_t_shortDesc_get, _csnd6.csCfgVariableInt_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableInt_t_longDesc_get, _csnd6.csCfgVariableInt_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")
    min = property(_csnd6.csCfgVariableInt_t_min_get, _csnd6.csCfgVariableInt_t_min_set, doc=r"""min : int""")
    max = property(_csnd6.csCfgVariableInt_t_max_get, _csnd6.csCfgVariableInt_t_max_set, doc=r"""max : int""")

    def __init__(self):
        r"""__init__(csCfgVariableInt_t self) -> csCfgVariableInt_t"""
        _csnd6.csCfgVariableInt_t_swiginit(self, _csnd6.new_csCfgVariableInt_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableInt_t

# Register csCfgVariableInt_t in _csnd6:
_csnd6.csCfgVariableInt_t_swigregister(csCfgVariableInt_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableBoolean_t_nxt_get, _csnd6.csCfgVariableBoolean_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableBoolean_t_name_get, _csnd6.csCfgVariableBoolean_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableBoolean_t_p_get, _csnd6.csCfgVariableBoolean_t_p_set, doc=r"""p : p.int""")
    type = property(_csnd6.csCfgVariableBoolean_t_type_get, _csnd6.csCfgVariableBoolean_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableBoolean_t_flags_get, _csnd6.csCfgVariableBoolean_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableBoolean_t_shortDesc_get, _csnd6.csCfgVariableBoolean_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableBoolean_t_longDesc_get, _csnd6.csCfgVariableBoolean_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")

    def __init__(self):
        r"""__init__(csCfgVariableBoolean_t self) -> csCfgVariableBoolean_t"""
        _csnd6.csCfgVariableBoolean_t_swiginit(self, _csnd6.new_csCfgVariableBoolean_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableBoolean_t

# Register csCfgVariableBoolean_t in _csnd6:
_csnd6.csCfgVariableBoolean_t_swigregister(csCfgVariableBoolean_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableFloat_t_nxt_get, _csnd6.csCfgVariableFloat_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableFloat_t_name_get, _csnd6.csCfgVariableFloat_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableFloat_t_p_get, _csnd6.csCfgVariableFloat_t_p_set, doc=r"""p : p.float""")
    type = property(_csnd6.csCfgVariableFloat_t_type_get, _csnd6.csCfgVariableFloat_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableFloat_t_flags_get, _csnd6.csCfgVariableFloat_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableFloat_t_shortDesc_get, _csnd6.csCfgVariableFloat_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableFloat_t_longDesc_get, _csnd6.csCfgVariableFloat_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")
    min = property(_csnd6.csCfgVariableFloat_t_min_get, _csnd6.csCfgVariableFloat_t_min_set, doc=r"""min : float""")
    max = property(_csnd6.csCfgVariableFloat_t_max_get, _csnd6.csCfgVariableFloat_t_max_set, doc=r"""max : float""")

    def __init__(self):
        r"""__init__(csCfgVariableFloat_t self) -> csCfgVariableFloat_t"""
        _csnd6.csCfgVariableFloat_t_swiginit(self, _csnd6.new_csCfgVariableFloat_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableFloat_t

# Register csCfgVariableFloat_t in _csnd6:
_csnd6.csCfgVariableFloat_t_swigregister(csCfgVariableFloat_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableDouble_t_nxt_get, _csnd6.csCfgVariableDouble_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableDouble_t_name_get, _csnd6.csCfgVariableDouble_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableDouble_t_p_get, _csnd6.csCfgVariableDouble_t_p_set, doc=r"""p : p.double""")
    type = property(_csnd6.csCfgVariableDouble_t_type_get, _csnd6.csCfgVariableDouble_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableDouble_t_flags_get, _csnd6.csCfgVariableDouble_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableDouble_t_shortDesc_get, _csnd6.csCfgVariableDouble_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableDouble_t_longDesc_get, _csnd6.csCfgVariableDouble_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")
    min = property(_csnd6.csCfgVariableDouble_t_min_get, _csnd6.csCfgVariableDouble_t_min_set, doc=r"""min : double""")
    max = property(_csnd6.csCfgVariableDouble_t_max_get, _csnd6.csCfgVariableDouble_t_max_set, doc=r"""max : double""")

    def __init__(self):
        r"""__init__(csCfgVariableDouble_t self) -> csCfgVariableDouble_t"""
        _csnd6.csCfgVariableDouble_t_swiginit(self, _csnd6.new_csCfgVariableDouble_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableDouble_t

# Register csCfgVariableDouble_t in _csnd6:
_csnd6.csCfgVariableDouble_t_swigregister(csCfgVariableDouble_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableMYFLT_t_nxt_get, _csnd6.csCfgVariableMYFLT_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableMYFLT_t_name_get, _csnd6.csCfgVariableMYFLT_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableMYFLT_t_p_get, _csnd6.csCfgVariableMYFLT_t_p_set, doc=r"""p : p.double""")
    type = property(_csnd6.csCfgVariableMYFLT_t_type_get, _csnd6.csCfgVariableMYFLT_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableMYFLT_t_flags_get, _csnd6.csCfgVariableMYFLT_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableMYFLT_t_shortDesc_get, _csnd6.csCfgVariableMYFLT_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableMYFLT_t_longDesc_get, _csnd6.csCfgVariableMYFLT_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")
    min = property(_csnd6.csCfgVariableMYFLT_t_min_get, _csnd6.csCfgVariableMYFLT_t_min_set, doc=r"""min : double""")
    max = property(_csnd6.csCfgVariableMYFLT_t_max_get, _csnd6.csCfgVariableMYFLT_t_max_set, doc=r"""max : double""")

    def __init__(self):
        r"""__init__(csCfgVariableMYFLT_t self) -> csCfgVariableMYFLT_t"""
        _csnd6.csCfgVariableMYFLT_t_swiginit(self, _csnd6.new_csCfgVariableMYFLT_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableMYFLT_t

# Register csCfgVariableMYFLT_t in _csnd6:
_csnd6.csCfgVariableMYFLT_t_swigregister(csCfgVariableMYFLT_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nxt = property(_csnd6.csCfgVariableString_t_nxt_get, _csnd6.csCfgVariableString_t_nxt_set, doc=r"""nxt : p.csCfgVariable_u""")
    name = property(_csnd6.csCfgVariableString_t_name_get, _csnd6.csCfgVariableString_t_name_set, doc=r"""name : p.unsigned char""")
    p = property(_csnd6.csCfgVariableString_t_p_get, _csnd6.csCfgVariableString_t_p_set, doc=r"""p : p.char""")
    type = property(_csnd6.csCfgVariableString_t_type_get, _csnd6.csCfgVariableString_t_type_set, doc=r"""type : int""")
    flags = property(_csnd6.csCfgVariableString_t_flags_get, _csnd6.csCfgVariableString_t_flags_set, doc=r"""flags : int""")
    shortDesc = property(_csnd6.csCfgVariableString_t_shortDesc_get, _csnd6.csCfgVariableString_t_shortDesc_set, doc=r"""shortDesc : p.unsigned char""")
    longDesc = property(_csnd6.csCfgVariableString_t_longDesc_get, _csnd6.csCfgVariableString_t_longDesc_set, doc=r"""longDesc : p.unsigned char""")
    maxlen = property(_csnd6.csCfgVariableString_t_maxlen_get, _csnd6.csCfgVariableString_t_maxlen_set, doc=r"""maxlen : int""")

    def __init__(self):
        r"""__init__(csCfgVariableString_t self) -> csCfgVariableString_t"""
        _csnd6.csCfgVariableString_t_swiginit(self, _csnd6.new_csCfgVariableString_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariableString_t

# Register csCfgVariableString_t in _csnd6:
_csnd6.csCfgVariableString_t_swigregister(csCfgVariableString_t)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    h = property(_csnd6.csCfgVariable_t_h_get, _csnd6.csCfgVariable_t_h_set, doc=r"""h : csCfgVariableHead_t""")
    i = property(_csnd6.csCfgVariable_t_i_get, _csnd6.csCfgVariable_t_i_set, doc=r"""i : csCfgVariableInt_t""")
    b = property(_csnd6.csCfgVariable_t_b_get, _csnd6.csCfgVariable_t_b_set, doc=r"""b : csCfgVariableBoolean_t""")
    f = property(_csnd6.csCfgVariable_t_f_get, _csnd6.csCfgVariable_t_f_set, doc=r"""f : csCfgVariableFloat_t""")
    d = property(_csnd6.csCfgVariable_t_d_get, _csnd6.csCfgVariable_t_d_set, doc=r"""d : csCfgVariableDouble_t""")
    m = property(_csnd6.csCfgVariable_t_m_get, _csnd6.csCfgVariable_t_m_set, doc=r"""m : csCfgVariableMYFLT_t""")
    s = property(_csnd6.csCfgVariable_t_s_get, _csnd6.csCfgVariable_t_s_set, doc=r"""s : csCfgVariableString_t""")

    def __init__(self):
        r"""__init__(csCfgVariable_t self) -> csCfgVariable_t"""
        _csnd6.csCfgVariable_t_swiginit(self, _csnd6.new_csCfgVariable_t())
    __swig_destroy__ = _csnd6.delete_csCfgVariable_t

# Register csCfgVariable_t in _csnd6:
_csnd6.csCfgVariable_t_swigregister(csCfgVariable_t)

CSOUNDCFG_INTEGER = _csnd6.CSOUNDCFG_INTEGER

CSOUNDCFG_BOOLEAN = _csnd6.CSOUNDCFG_BOOLEAN

CSOUNDCFG_FLOAT = _csnd6.CSOUNDCFG_FLOAT

CSOUNDCFG_DOUBLE = _csnd6.CSOUNDCFG_DOUBLE

CSOUNDCFG_MYFLT = _csnd6.CSOUNDCFG_MYFLT

CSOUNDCFG_STRING = _csnd6.CSOUNDCFG_STRING

CSOUNDCFG_POWOFTWO = _csnd6.CSOUNDCFG_POWOFTWO

CSOUNDCFG_SUCCESS = _csnd6.CSOUNDCFG_SUCCESS

CSOUNDCFG_INVALID_NAME = _csnd6.CSOUNDCFG_INVALID_NAME

CSOUNDCFG_INVALID_TYPE = _csnd6.CSOUNDCFG_INVALID_TYPE

CSOUNDCFG_INVALID_FLAG = _csnd6.CSOUNDCFG_INVALID_FLAG

CSOUNDCFG_NULL_POINTER = _csnd6.CSOUNDCFG_NULL_POINTER

CSOUNDCFG_TOO_HIGH = _csnd6.CSOUNDCFG_TOO_HIGH

CSOUNDCFG_TOO_LOW = _csnd6.CSOUNDCFG_TOO_LOW

CSOUNDCFG_NOT_POWOFTWO = _csnd6.CSOUNDCFG_NOT_POWOFTWO

CSOUNDCFG_INVALID_BOOLEAN = _csnd6.CSOUNDCFG_INVALID_BOOLEAN

CSOUNDCFG_MEMORY = _csnd6.CSOUNDCFG_MEMORY

CSOUNDCFG_STRING_LENGTH = _csnd6.CSOUNDCFG_STRING_LENGTH

CSOUNDCFG_LASTERROR = _csnd6.CSOUNDCFG_LASTERROR


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

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

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

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

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

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

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

def csoundCfgErrorCodeToString(errcode):
    r"""csoundCfgErrorCodeToString(int errcode) -> char const *"""
    return _csnd6.csoundCfgErrorCodeToString(errcode)
CSOUNDMSG_DEFAULT = _csnd6.CSOUNDMSG_DEFAULT

CSOUNDMSG_ERROR = _csnd6.CSOUNDMSG_ERROR

CSOUNDMSG_ORCH = _csnd6.CSOUNDMSG_ORCH

CSOUNDMSG_REALTIME = _csnd6.CSOUNDMSG_REALTIME

CSOUNDMSG_WARNING = _csnd6.CSOUNDMSG_WARNING

CSOUNDMSG_STDOUT = _csnd6.CSOUNDMSG_STDOUT

CSOUNDMSG_FG_BLACK = _csnd6.CSOUNDMSG_FG_BLACK

CSOUNDMSG_FG_RED = _csnd6.CSOUNDMSG_FG_RED

CSOUNDMSG_FG_GREEN = _csnd6.CSOUNDMSG_FG_GREEN

CSOUNDMSG_FG_YELLOW = _csnd6.CSOUNDMSG_FG_YELLOW

CSOUNDMSG_FG_BLUE = _csnd6.CSOUNDMSG_FG_BLUE

CSOUNDMSG_FG_MAGENTA = _csnd6.CSOUNDMSG_FG_MAGENTA

CSOUNDMSG_FG_CYAN = _csnd6.CSOUNDMSG_FG_CYAN

CSOUNDMSG_FG_WHITE = _csnd6.CSOUNDMSG_FG_WHITE

CSOUNDMSG_FG_BOLD = _csnd6.CSOUNDMSG_FG_BOLD

CSOUNDMSG_FG_UNDERLINE = _csnd6.CSOUNDMSG_FG_UNDERLINE

CSOUNDMSG_BG_BLACK = _csnd6.CSOUNDMSG_BG_BLACK

CSOUNDMSG_BG_RED = _csnd6.CSOUNDMSG_BG_RED

CSOUNDMSG_BG_GREEN = _csnd6.CSOUNDMSG_BG_GREEN

CSOUNDMSG_BG_ORANGE = _csnd6.CSOUNDMSG_BG_ORANGE

CSOUNDMSG_BG_BLUE = _csnd6.CSOUNDMSG_BG_BLUE

CSOUNDMSG_BG_MAGENTA = _csnd6.CSOUNDMSG_BG_MAGENTA

CSOUNDMSG_BG_CYAN = _csnd6.CSOUNDMSG_BG_CYAN

CSOUNDMSG_BG_GREY = _csnd6.CSOUNDMSG_BG_GREY

CSOUNDMSG_TYPE_MASK = _csnd6.CSOUNDMSG_TYPE_MASK

CSOUNDMSG_FG_COLOR_MASK = _csnd6.CSOUNDMSG_FG_COLOR_MASK

CSOUNDMSG_FG_ATTR_MASK = _csnd6.CSOUNDMSG_FG_ATTR_MASK

CSOUNDMSG_BG_COLOR_MASK = _csnd6.CSOUNDMSG_BG_COLOR_MASK

VERSION = _csnd6.VERSION

CS_PACKAGE_NAME = _csnd6.CS_PACKAGE_NAME

CS_PACKAGE_STRING = _csnd6.CS_PACKAGE_STRING

CS_PACKAGE_TARNAME = _csnd6.CS_PACKAGE_TARNAME

CS_PACKAGE_VERSION = _csnd6.CS_PACKAGE_VERSION

CS_VERSION = _csnd6.CS_VERSION

CS_SUBVER = _csnd6.CS_SUBVER

CS_PATCHLEVEL = _csnd6.CS_PATCHLEVEL

CS_APIVERSION = _csnd6.CS_APIVERSION

CS_APISUBVER = _csnd6.CS_APISUBVER


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

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

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

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

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

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

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

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

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

def csoundGetInstance(obj):
    r"""csoundGetInstance(int64_t obj) -> CSOUND *"""
    return _csnd6.csoundGetInstance(obj)
MESSAGE_BUFFER_LENGTH = _csnd6.MESSAGE_BUFFER_LENGTH

class pycbdata(object):
    r"""Proxy of C++ pycbdata class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mfunc = property(_csnd6.pycbdata_mfunc_get, _csnd6.pycbdata_mfunc_set, doc=r"""mfunc : p.PyObject""")
    invalfunc = property(_csnd6.pycbdata_invalfunc_get, _csnd6.pycbdata_invalfunc_set, doc=r"""invalfunc : p.PyObject""")
    outvalfunc = property(_csnd6.pycbdata_outvalfunc_get, _csnd6.pycbdata_outvalfunc_set, doc=r"""outvalfunc : p.PyObject""")
    midiinopenfunc = property(_csnd6.pycbdata_midiinopenfunc_get, _csnd6.pycbdata_midiinopenfunc_set, doc=r"""midiinopenfunc : p.PyObject""")
    midireadfunc = property(_csnd6.pycbdata_midireadfunc_get, _csnd6.pycbdata_midireadfunc_set, doc=r"""midireadfunc : p.PyObject""")
    midiinclosefunc = property(_csnd6.pycbdata_midiinclosefunc_get, _csnd6.pycbdata_midiinclosefunc_set, doc=r"""midiinclosefunc : p.PyObject""")
    hostdata = property(_csnd6.pycbdata_hostdata_get, _csnd6.pycbdata_hostdata_set, doc=r"""hostdata : p.PyObject""")
    messageBuffer = property(_csnd6.pycbdata_messageBuffer_get, _csnd6.pycbdata_messageBuffer_set, doc=r"""messageBuffer : a(8192).char""")
    messageBufferIndex = property(_csnd6.pycbdata_messageBufferIndex_get, _csnd6.pycbdata_messageBufferIndex_set, doc=r"""messageBufferIndex : int""")

    def __init__(self):
        r"""__init__(pycbdata self) -> pycbdata"""
        _csnd6.pycbdata_swiginit(self, _csnd6.new_pycbdata())
    __swig_destroy__ = _csnd6.delete_pycbdata

# Register pycbdata in _csnd6:
_csnd6.pycbdata_swigregister(pycbdata)

class Csound(object):
    r"""Proxy of C++ Csound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pydata = property(_csnd6.Csound_pydata_get, _csnd6.Csound_pydata_set, doc=r"""pydata : p.void""")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(Csound self) -> Csound
        __init__(Csound self, CSOUND * csound_) -> Csound
        __init__(Csound self, void * hostData) -> Csound
        """
        _csnd6.Csound_swiginit(self, _csnd6.new_Csound(*args))
    __swig_destroy__ = _csnd6.delete_Csound

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register Csound in _csnd6:
_csnd6.Csound_swigregister(Csound)

class CsoundThreadLock(object):
    r"""Proxy of C++ CsoundThreadLock class."""

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundThreadLock self) -> CsoundThreadLock
        __init__(CsoundThreadLock self, int locked) -> CsoundThreadLock
        """
        _csnd6.CsoundThreadLock_swiginit(self, _csnd6.new_CsoundThreadLock(*args))
    __swig_destroy__ = _csnd6.delete_CsoundThreadLock

# Register CsoundThreadLock in _csnd6:
_csnd6.CsoundThreadLock_swigregister(CsoundThreadLock)

class CsoundMutex(object):
    r"""Proxy of C++ CsoundMutex class."""

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundMutex self) -> CsoundMutex
        __init__(CsoundMutex self, int isRecursive) -> CsoundMutex
        """
        _csnd6.CsoundMutex_swiginit(self, _csnd6.new_CsoundMutex(*args))
    __swig_destroy__ = _csnd6.delete_CsoundMutex

# Register CsoundMutex in _csnd6:
_csnd6.CsoundMutex_swigregister(CsoundMutex)

class CsoundRandMT(object):
    r"""Proxy of C++ CsoundRandMT class."""

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundRandMT self) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t seedVal) -> CsoundRandMT
        __init__(CsoundRandMT self, uint32_t const * initKey, int keyLength) -> CsoundRandMT
        """
        _csnd6.CsoundRandMT_swiginit(self, _csnd6.new_CsoundRandMT(*args))
    __swig_destroy__ = _csnd6.delete_CsoundRandMT

# Register CsoundRandMT in _csnd6:
_csnd6.CsoundRandMT_swigregister(CsoundRandMT)

class CsoundTimer(object):
    r"""Proxy of C++ CsoundTimer class."""

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

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

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

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

    def __init__(self):
        r"""__init__(CsoundTimer self) -> CsoundTimer"""
        _csnd6.CsoundTimer_swiginit(self, _csnd6.new_CsoundTimer())
    __swig_destroy__ = _csnd6.delete_CsoundTimer

# Register CsoundTimer in _csnd6:
_csnd6.CsoundTimer_swigregister(CsoundTimer)

class CsoundOpcodeList(object):
    r"""Proxy of C++ CsoundOpcodeList class."""

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundOpcodeList self, CSOUND * csound) -> CsoundOpcodeList
        __init__(CsoundOpcodeList self, Csound csound) -> CsoundOpcodeList
        """
        _csnd6.CsoundOpcodeList_swiginit(self, _csnd6.new_CsoundOpcodeList(*args))
    __swig_destroy__ = _csnd6.delete_CsoundOpcodeList

# Register CsoundOpcodeList in _csnd6:
_csnd6.CsoundOpcodeList_swigregister(CsoundOpcodeList)

class CsoundChannelList(object):
    r"""Proxy of C++ CsoundChannelList class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundChannelList self, CSOUND * csound) -> CsoundChannelList
        __init__(CsoundChannelList self, Csound csound) -> CsoundChannelList
        """
        _csnd6.CsoundChannelList_swiginit(self, _csnd6.new_CsoundChannelList(*args))
    __swig_destroy__ = _csnd6.delete_CsoundChannelList

# Register CsoundChannelList in _csnd6:
_csnd6.CsoundChannelList_swigregister(CsoundChannelList)

class CsoundUtilityList(object):
    r"""Proxy of C++ CsoundUtilityList class."""

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundUtilityList self, CSOUND * csound) -> CsoundUtilityList
        __init__(CsoundUtilityList self, Csound csound) -> CsoundUtilityList
        """
        _csnd6.CsoundUtilityList_swiginit(self, _csnd6.new_CsoundUtilityList(*args))
    __swig_destroy__ = _csnd6.delete_CsoundUtilityList

# Register CsoundUtilityList in _csnd6:
_csnd6.CsoundUtilityList_swigregister(CsoundUtilityList)

class CsoundMYFLTArray(object):
    r"""Proxy of C++ CsoundMYFLTArray class."""

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundMYFLTArray self) -> CsoundMYFLTArray
        __init__(CsoundMYFLTArray self, int n) -> CsoundMYFLTArray
        """
        _csnd6.CsoundMYFLTArray_swiginit(self, _csnd6.new_CsoundMYFLTArray(*args))
    __swig_destroy__ = _csnd6.delete_CsoundMYFLTArray

# Register CsoundMYFLTArray in _csnd6:
_csnd6.CsoundMYFLTArray_swigregister(CsoundMYFLTArray)

class CsoundArgVList(object):
    r"""Proxy of C++ CsoundArgVList class."""

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

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

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

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

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

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

    def __init__(self):
        r"""__init__(CsoundArgVList self) -> CsoundArgVList"""
        _csnd6.CsoundArgVList_swiginit(self, _csnd6.new_CsoundArgVList())
    __swig_destroy__ = _csnd6.delete_CsoundArgVList

# Register CsoundArgVList in _csnd6:
_csnd6.CsoundArgVList_swigregister(CsoundArgVList)

class CsoundCallbackWrapper(object):
    r"""Proxy of C++ CsoundCallbackWrapper class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundCallbackWrapper self, Csound csound) -> CsoundCallbackWrapper
        __init__(CsoundCallbackWrapper self, CSOUND * csound) -> CsoundCallbackWrapper
        """
        if self.__class__ == CsoundCallbackWrapper:
            _self = None
        else:
            _self = self
        _csnd6.CsoundCallbackWrapper_swiginit(self, _csnd6.new_CsoundCallbackWrapper(_self, *args))
    __swig_destroy__ = _csnd6.delete_CsoundCallbackWrapper
    def __disown__(self):
        self.this.disown()
        _csnd6.disown_CsoundCallbackWrapper(self)
        return weakref.proxy(self)

# Register CsoundCallbackWrapper in _csnd6:
_csnd6.CsoundCallbackWrapper_swigregister(CsoundCallbackWrapper)

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

class CsoundMidiInputBuffer(object):
    r"""Proxy of C++ CsoundMidiInputBuffer class."""

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

    def __init__(self, buf, bufSize):
        r"""__init__(CsoundMidiInputBuffer self, unsigned char * buf, int bufSize) -> CsoundMidiInputBuffer"""
        _csnd6.CsoundMidiInputBuffer_swiginit(self, _csnd6.new_CsoundMidiInputBuffer(buf, bufSize))
    __swig_destroy__ = _csnd6.delete_CsoundMidiInputBuffer

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

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

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

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

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

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

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

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

# Register CsoundMidiInputBuffer in _csnd6:
_csnd6.CsoundMidiInputBuffer_swigregister(CsoundMidiInputBuffer)

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundMidiInputStream self, CSOUND * csound) -> CsoundMidiInputStream
        __init__(CsoundMidiInputStream self, Csound csound) -> CsoundMidiInputStream
        """
        _csnd6.CsoundMidiInputStream_swiginit(self, _csnd6.new_CsoundMidiInputStream(*args))

    def EnableMidiInput(self, argv):
        r"""EnableMidiInput(CsoundMidiInputStream self, CsoundArgVList argv)"""
        return _csnd6.CsoundMidiInputStream_EnableMidiInput(self, argv)
    __swig_destroy__ = _csnd6.delete_CsoundMidiInputStream

# Register CsoundMidiInputStream in _csnd6:
_csnd6.CsoundMidiInputStream_swigregister(CsoundMidiInputStream)

class CsoundMidiOutputBuffer(object):
    r"""Proxy of C++ CsoundMidiOutputBuffer class."""

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

    def __init__(self, buf, bufSize):
        r"""__init__(CsoundMidiOutputBuffer self, unsigned char * buf, int bufSize) -> CsoundMidiOutputBuffer"""
        _csnd6.CsoundMidiOutputBuffer_swiginit(self, _csnd6.new_CsoundMidiOutputBuffer(buf, bufSize))
    __swig_destroy__ = _csnd6.delete_CsoundMidiOutputBuffer

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

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

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

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

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

# Register CsoundMidiOutputBuffer in _csnd6:
_csnd6.CsoundMidiOutputBuffer_swigregister(CsoundMidiOutputBuffer)

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundMidiOutputStream self, CSOUND * csound) -> CsoundMidiOutputStream
        __init__(CsoundMidiOutputStream self, Csound csound) -> CsoundMidiOutputStream
        """
        _csnd6.CsoundMidiOutputStream_swiginit(self, _csnd6.new_CsoundMidiOutputStream(*args))

    def EnableMidiOutput(self, argv):
        r"""EnableMidiOutput(CsoundMidiOutputStream self, CsoundArgVList argv)"""
        return _csnd6.CsoundMidiOutputStream_EnableMidiOutput(self, argv)
    __swig_destroy__ = _csnd6.delete_CsoundMidiOutputStream

# Register CsoundMidiOutputStream in _csnd6:
_csnd6.CsoundMidiOutputStream_swigregister(CsoundMidiOutputStream)

_MM_DENORMALS_ZERO_MASK = _csnd6._MM_DENORMALS_ZERO_MASK

_MM_DENORMALS_ZERO_ON = _csnd6._MM_DENORMALS_ZERO_ON

_MM_DENORMALS_ZERO_OFF = _csnd6._MM_DENORMALS_ZERO_OFF

class pycallbackdata(object):
    r"""Proxy of C++ pycallbackdata class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    func = property(_csnd6.pycallbackdata_func_get, _csnd6.pycallbackdata_func_set, doc=r"""func : p.PyObject""")
    data = property(_csnd6.pycallbackdata_data_get, _csnd6.pycallbackdata_data_set, doc=r"""data : p.PyObject""")

    def __init__(self):
        r"""__init__(pycallbackdata self) -> pycallbackdata"""
        _csnd6.pycallbackdata_swiginit(self, _csnd6.new_pycallbackdata())
    __swig_destroy__ = _csnd6.delete_pycallbackdata

# Register pycallbackdata in _csnd6:
_csnd6.pycallbackdata_swigregister(pycallbackdata)

class recordData_t(object):
    r"""Proxy of C++ recordData_t class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cbuf = property(_csnd6.recordData_t_cbuf_get, _csnd6.recordData_t_cbuf_set, doc=r"""cbuf : p.void""")
    sfile = property(_csnd6.recordData_t_sfile_get, _csnd6.recordData_t_sfile_set, doc=r"""sfile : p.void""")
    thread = property(_csnd6.recordData_t_thread_get, _csnd6.recordData_t_thread_set, doc=r"""thread : p.void""")
    running = property(_csnd6.recordData_t_running_get, _csnd6.recordData_t_running_set, doc=r"""running : bool""")
    condvar = property(_csnd6.recordData_t_condvar_get, _csnd6.recordData_t_condvar_set, doc=r"""condvar : p.void""")
    mutex = property(_csnd6.recordData_t_mutex_get, _csnd6.recordData_t_mutex_set, doc=r"""mutex : p.void""")

    def __init__(self):
        r"""__init__(recordData_t self) -> recordData_t"""
        _csnd6.recordData_t_swiginit(self, _csnd6.new_recordData_t())
    __swig_destroy__ = _csnd6.delete_recordData_t

# Register recordData_t in _csnd6:
_csnd6.recordData_t_swigregister(recordData_t)

class CsoundPerformanceThread(object):
    r"""Proxy of C++ CsoundPerformanceThread class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    _tstate = property(_csnd6.CsoundPerformanceThread__tstate_get, _csnd6.CsoundPerformanceThread__tstate_set, doc=r"""_tstate : p.PyThreadState""")
    pydata = property(_csnd6.CsoundPerformanceThread_pydata_get, _csnd6.CsoundPerformanceThread_pydata_set, doc=r"""pydata : pycallbackdata""")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CsoundPerformanceThread self, Csound arg2) -> CsoundPerformanceThread
        __init__(CsoundPerformanceThread self, CSOUND * arg2) -> CsoundPerformanceThread
        """
        _csnd6.CsoundPerformanceThread_swiginit(self, _csnd6.new_CsoundPerformanceThread(*args))
    __swig_destroy__ = _csnd6.delete_CsoundPerformanceThread

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

# Register CsoundPerformanceThread in _csnd6:
_csnd6.CsoundPerformanceThread_swigregister(CsoundPerformanceThread)

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

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

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

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

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

    def __len__(self):
        r"""__len__(IntToStringMap self) -> std::map< int,std::string >::size_type"""
        return _csnd6.IntToStringMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(IntToStringMap self, std::map< int,std::string >::key_type const & key) -> std::map< int,std::string >::mapped_type const &"""
        return _csnd6.IntToStringMap___getitem__(self, key)

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(IntToStringMap self, std::less< int > const & other) -> IntToStringMap
        __init__(IntToStringMap self) -> IntToStringMap
        __init__(IntToStringMap self, IntToStringMap other) -> IntToStringMap
        """
        _csnd6.IntToStringMap_swiginit(self, _csnd6.new_IntToStringMap(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register IntToStringMap in _csnd6:
_csnd6.IntToStringMap_swigregister(IntToStringMap)


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

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

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

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    libraryFilename = property(_csnd6.CsoundFile_libraryFilename_get, _csnd6.CsoundFile_libraryFilename_set, doc=r"""libraryFilename : std::string""")
    arrangement = property(_csnd6.CsoundFile_arrangement_get, _csnd6.CsoundFile_arrangement_set, doc=r"""arrangement : std::vector<(std::string,std::allocator<(std::string)>)>""")

    def __init__(self):
        r"""__init__(CsoundFile self) -> CsoundFile"""
        _csnd6.CsoundFile_swiginit(self, _csnd6.new_CsoundFile())
    __swig_destroy__ = _csnd6.delete_CsoundFile

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register CsoundFile in _csnd6:
_csnd6.CsoundFile_swigregister(CsoundFile)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(MyfltVector self) -> MyfltVector
        __init__(MyfltVector self, MyfltVector other) -> MyfltVector
        __init__(MyfltVector self, std::vector< double >::size_type size) -> MyfltVector
        __init__(MyfltVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> MyfltVector
        """
        _csnd6.MyfltVector_swiginit(self, _csnd6.new_MyfltVector(*args))

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

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

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

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

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

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

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

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

# Register MyfltVector in _csnd6:
_csnd6.MyfltVector_swigregister(MyfltVector)

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

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

    def __init__(self):
        r"""__init__(CppSound self) -> CppSound"""
        _csnd6.CppSound_swiginit(self, _csnd6.new_CppSound())
    __swig_destroy__ = _csnd6.delete_CppSound

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register CppSound in _csnd6:
_csnd6.CppSound_swigregister(CppSound)



