/*
  ==============================================================================

    CabbageStrings.h
    Created: 17 Oct 2016 4:15:42pm
    Author:  rory

  ==============================================================================
*/

#ifndef CABBAGESTRINGS_H_INCLUDED
#define CABBAGESTRINGS_H_INCLUDED

class CabbageStrings
{

public:
    CabbageStrings()
    {
    }

    ~CabbageStrings() {}


    static String getNewCsoundFileText()
    {
        String newCsoundFile =  "<CsoundSynthesizer>\n"
                                "<CsOptions>\n"
                                "-n -d \n"
                                "</CsOptions>\n"
                                "<CsInstruments>\n"
                                "; Initialize the global variables. \n"
                                "ksmps = 32\n"
                                "nchnls = 2\n"
                                "0dbfs = 1\n"
                                "\n"
                                "instr 99\n"
                                "\n"
                                "endin\n"
                                "\n"
                                "</CsInstruments>\n"
                                "<CsScore>\n"
                                "i99 0 10\n"
                                "</CsScore>\n"
                                "</CsoundSynthesizer>";
        return newCsoundFile;
    }

    static String getNewCabbageInstrumentFileText()
    {
        String newCsoundFile =
            "<Cabbage>\n"
            "form caption(\"Untitled\") size(400, 300), guiMode(\"queue\"), pluginId(\"def1\")\n"
            "keyboard bounds(8, 158, 381, 95)\n"
            "</Cabbage>\n"
            "<CsoundSynthesizer>\n"
            "<CsOptions>\n"
            "-n -d -+rtmidi=NULL -M0 --midi-key-cps=4 --midi-velocity-amp=5\n"
            "</CsOptions>\n"
            "<CsInstruments>\n"
            "; Initialize the global variables. \n"
            "ksmps = 32\n"
            "nchnls = 2\n"
            "0dbfs = 1\n"
            "\n"
            ";instrument will be triggered by keyboard widget\n"
            "instr 1\n"
            "kEnv madsr .1, .2, .6, .4\n"
            "aOut vco2 p5, p4\n"
            "outs aOut*kEnv, aOut*kEnv\n"
            "endin\n"
            "\n"
            "</CsInstruments>\n"
            "<CsScore>\n"
            ";causes Csound to run for about 7000 years...\n"
            "f0 z\n"
            "</CsScore>\n"
            "</CsoundSynthesizer>\n"
            "";

        return newCsoundFile;
    }

    static String getNewRackModuleFileText()
    {
            String newRackFile =
        "<Cabbage>\n"
        "form caption(\"CabbageModule\") size(100, 380), colour(255, 255, 255), pluginId(\"def1\")\n"
        "screw bounds(5, 10, 15, 15)\n"
        "screw bounds(80, 10, 15, 15)\n"
        "screw bounds(5, 360, 15, 15)\n"
        "screw bounds(80, 360, 15, 15)\n"
        "\n"
        "cvinput bounds(34, 60, 30, 30), channel(\"input1\")\n"
        "label bounds(0, 90, 100, 12), fontColour(0,0,0) text(\"Input\")\n"
        "cvoutput bounds(34, 300, 30, 30), channel(\"output1\")\n"
        "label bounds(0, 330, 100, 12), fontColour(0,0,0) text(\"Output\")\n"
        "rslider bounds(0, 150, 100, 100), channel(\"gain\"), text(\"Gain\"), textColour(0, 0, 0, 255), range(0, 1, 0, 1, 0.01)\n"
        "light bounds(45, 250, 10, 10), channel(\"light1\")\n"
        "</Cabbage>\n"
        "<CsoundSynthesizer>\n"
        "<CsOptions>\n"
        "-n -d \n"
        "</CsOptions>\n"
        "<CsInstruments>\n"
        "; Initialize the global variables. \n"
        "ksmps = 32\n"
        "nchnls = 2\n"
        "0dbfs = 1\n"
        "\n"
        "\n"
        "instr 1\n"
        "    kLightBrightness init 0\n"
        "    aInput chnget \"cvInput1\"\n"
        "    printk2 chnget:k(\"gain\")\n"
        "    aOut = aInput*chnget:k(\"gain\")\n"
        "    chnset aOut, \"cvOutput1\"\n"
        "    \n"
        "    if metro(2) == 1 then\n"
        "        kLightBrightness = kLightBrightness == 0 ? .8 : 0\n"
        "        chnset kLightBrightness, \"light1\"\n"
        "    endif\n"
        "    \n"
        "    \n"
        "endin\n"
        "\n"
        "</CsInstruments>\n"
        "<CsScore>\n"
        ";starts instrument 1 and runs it for a week\n"
        "i1 0 [60*60*24*7] \n"
        "</CsScore>\n"
        "</CsoundSynthesizer>\n"
        "";
        return newRackFile;
    }
    
    static String getVSEditorHTML() {
        return {CharPointer_UTF8(R"xxx(
<!doctype html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <title>Monaco editor</title>
    <style type="text/css" media="screen">
        body {
            background-color: rgb(30, 30, 30);
            overflow: hidden;
            /* Hide scrollbars */
        }

        #container {
            position: absolute;
            top: 0px;
            right: 0px;
            bottom: 0px;
            left: 0px;
            margin-top: 0px;
            margin-bottom: 25px;
        }
    </style>
    <link rel="stylesheet" data-name="vs/editor/editor.main"
        href="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.20.0/min/vs/editor/editor.main.min.css">
</head>

<body>
    <div id="container"></div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.40.0/min/vs/loader.min.js"></script>
    <script>

        // require is provided by loader.min.js.
        let editor;
        var suggestions = [];
        require.config({ paths: { 'vs': 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.26.1/min/vs' } });
        require(["vs/editor/editor.main"], () => {
    console.log('=============================================');
            editor = monaco.editor.create(document.getElementById('container'), {
                value: `
                <CsoundSynthesizer>
<CsOptions>
; Select audio/midi flags here according to platform
; Audio out   Audio in    No messages
-odac           -iadc     -d     ;;;RT audio I/O
; For Non-realtime ouput leave only the line below:
; -o vco2.wav -W ;;; for file output any platform
</CsOptions>
<CsInstruments>

sr      =  44100
ksmps   =  10
nchnls  =  1

; user defined waveform -1: trapezoid wave with default parameters (can be
; accessed at ftables starting from 10000)
itmp    ftgen 1, 0, 16384, 7, 0, 2048, 1, 4096, 1, 4096, -1, 4096, -1, 2048, 0
ift     vco2init -1, 10000, 0, 0, 0, 1
; user defined waveform -2: fixed table size (4096), number of partials
; multiplier is 1.02 (~238 tables)
itmp    ftgen 2, 0, 16384, 7, 1, 4095, 1, 1, -1, 4095, -1, 1, 0, 8192, 0
ift     vco2init -2, ift, 1.02, 4096, 4096, 2

        instr 1
kcps    expon p4, p3, p5                ; instr 1: basic vco2 example
a1      vco2 12000, kcps                ; (sawtooth wave with default
        out a1                          ; parameters)
        endin

        instr 2
kcps    expon p4, p3, p5                        ; instr 2:
kpw     linseg 0.1, p3/2, 0.9, p3/2, 0.1        ; PWM example
a1      vco2 10000, kcps, 2, kpw
        out a1
        endin

        instr 3
kcps    expon p4, p3, p5                ; instr 3: vco2 with user
a1      vco2 14000, kcps, 14            ; defined waveform (-1)
aenv    linseg 1, p3 - 0.1, 1, 0.1, 0   ; de-click envelope
        out a1 * aenv
        endin

        instr 4
kcps    expon p4, p3, p5                ; instr 4: vco2ft example,
kfn     vco2ft kcps, -2, 0.25           ; with user defined waveform
a1      oscilikt 12000, kcps, kfn       ; (-2), and sr/4 bandwidth
        out a1
        endin


</CsInstruments>
<CsScore>

i 1  0 3 20 2000
i 2  4 2 200 400
i 3  7 3 400 20
i 4 11 2 100 200

f 0 14

e


</CsScore>
</CsoundSynthesizer>
                `,


                language: 'mySpecialLanguage',
                //theme: 'vs-dark',
                "editor.quickSuggestions": {
                    "other": "inline", // the `inline` value is new
                    "comments": true,
                    "strings": true
                },
                automaticLayout: true,
                minimap: {
                    enabled: false
                },
                formatOnPaste: true
            });

            // Register a new language
            monaco.languages.register({ id: 'mySpecialLanguage' });

            // Register a tokens provider for the language
            monaco.languages.setMonarchTokensProvider('mySpecialLanguage', {
                keywords: [
                    'abstract', 'continue', 'for', 'new', 'switch', 'assert', 'goto', 'do',
                    'if', 'private', 'this', 'break', 'protected', 'throw', 'else', 'public',
                    'enum', 'return', 'catch', 'try', 'interface', 'static', 'class',
                    'finally', 'const', 'super', 'while', 'true', 'false'
                ],

                typeKeywords: [
                    'boolean', 'double', 'byte', 'int', 'short', 'char', 'void', 'long', 'float'
                ],

                operators: [
                    '=', '>', '<', '!', '~', '?', ':', '==', '<=', '>=', '!=',
                    '&&', '||', '++', '--', '+', '-', '*', '/', '&', '|', '^', '%',
                    '<<', '>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=', '^=',
                    '%=', '<<=', '>>=', '>>>='
                ],

                // we include these common regular expressions
                symbols: /[=><!~?:&|+\-*\/\^%]+/,

                // C# style strings
                escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,

                // The main tokenizer for our languages
                tokenizer: {
                    root: [
                        // Comments
                        [/;.*$/, "comment"],

                        // Instrument and score statements
                        // Keywords
                        ["<CsOptions>|</CsOptions>|<CsInstruments>|</CsInstruments>|</CsScore>|</CsoundSynthesizer>|<CsScore>|<CsoundSynthesizer>", "cs-tags"],
                        ["if |then|else|elseif|endif", "control-flow"],


                        ["sr|nchnls|ksmps|kr|0dbfs", "keyword"],
                        ["instr|endin", "instrDefine"],
                        ["endin", "keyword"],
                        [/\b[a]\w*/, "variables"],
                        [/\b[i]\w*/, "variables"],
                        [/\b[f]\w*/, "variables"],
                        [/\b[S]\w*/, "variables"],
                        [/\b[k]\w*/, "variables"],
                        // [/\b(?:<\/CsOptions>|<CsInstruments>|<CsOptions>|<\/CsInstruments>|<\/CsScore>|<\/CsoundSynthesizer>|<CsScore>|<CsoundSynthesizer>)\b/, "tag"],
                        // Opcode names
                        [/\b[^a\d]\w*/, "opcode"],
                        [/\b[^i\d]\w*/, "opcode"],
                        [/\b[^k\d]\w*/, "opcode"],
                        [/\b[^f\d]\w*/, "opcode"],
                        [/\b[^S\d]\w*/, "opcode"],

                        [/[a-zA-Z_]\w*/, "opcode"],

                        // Numbers
                        [/\b\d+(\.\d+)?\b/, "number"],

                        // Strings
                        [/"(?:\\.|[^"])*"/, "string"],


                    ]
                },

            });

            monaco.editor.defineTheme("myTheme", {
                base: "vs-dark",
                inherit: true,
                rules: [
//                    { token: "cs-tags", foreground: '#3F90CC', fontStyle: "bold" },
//                    { token: "control-flow", foreground: '#518048' },
//                    { token: "variables", foreground: '#dddddd' },
//                    { token: "opcode", foreground: '#3F90CC', fontStyle: "bold" },
//                    { token: "string", foreground: '#FF8C00', fontStyle: "bold" },
//                    { token: "keyword", foreground: '#dddddd', fontStyle: "normal" },
//                    { token: "instrDefine", foreground: '#3F90CC', fontStyle: "bold" },
//                    { token: "number", foreground: '#518048', fontStyle: "normal" },

                ],
                colors: {
                    //"editor.background": "#191E2B",
                    "editorLineNumber.foreground" : "#ff0000"
                },
            });
            monaco.editor.setTheme("myTheme");
            editor.getModel().updateOptions({ tabSize: 2 })
            editor.onDidPaste((e) => {
                updatePropertiesCallback(JSON.parse(editor.getValue()));
            })

            var myBinding = editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KEY_Y, function () {
                alert('CMD + Y pressed!');
            });

            editor.onDidChangeModelContent(function (e) {
                if (e.isFlush) {
                    console.log("setValue called")
                } else {
                    updatePropertiesCallback(JSON.parse(editor.getValue()));
                }

                console.log("text changed");

                //editor.getAction('editor.action.formatDocument').run();
            });

            editor.getAction('editor.action.triggerSuggest').run().then(() => console.log('finished'));
            let actions = editor.getSupportedActions().map((a) => a.id);
            actions.forEach(e => console.log(e));

            editor.setPosition({ column: 9, lineNumber: 3 });

            editor.focus();

            suggestions = [
                {
                    label: 'range',
                    kind: monaco.languages.CompletionItemKind.Snippet,
                    documentation: 'Add an a range parameter',
                    command: {
                        id: 'editor.action.triggerSuggest',
                        title: 'operator_additional_suggestions',
                    },
                    insertText: [
                        '"name": {    "type": "range","increment": 0.001,"max": 1.0,"min": 0.0,"skew": 1.0, "value":0,',
                        '"nodeParameters":{',
                        '}',
                        '}'].join('\n')
                },
                {
                    label: 'keyboard',
                    kind: monaco.languages.CompletionItemKind.Snippet,
                    documentation: 'Add an a range parameter',
                    command: {
                        id: 'editor.action.triggerSuggest',
                        title: 'operator_additional_suggestions',
                    },
                    insertText: [
                        '"keyboard": {    "min": 48.0,"max": 72.0',
                        '}'].join('\n')
                },
                {
                    label: 'button',
                    kind: monaco.languages.CompletionItemKind.Snippet,
                    documentation: 'Add an a button parameter',
                    command: {
                        id: 'editor.action.triggerSuggest',
                        title: 'operator_additional_suggestions',
                    },
                    insertText: [
                        '"name": {    "type": "button","increment": 0.1,"max": 1.0,"min": 0.0, "value":0, "onText": "On", "offText": "Off",',
                        '"nodeParameters":{',
                        '}',
                        '}'].join('\n')
                }
            ]

            monaco.languages.registerCompletionItemProvider('mySpecialLanguage', {
                provideCompletionItems: () => {
                    return {
                        suggestions
                    };
                }
            });
        });//end of require

        window.addEventListener('keydown', function (event) {
            if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event.shiftKey || window.chrome || window.opera)) {
                event.preventDefault();
                if (event.stopImmediatePropagation) {
                    event.stopImmediatePropagation();
                } else {
                    event.stopPropagation();
                }
                updatePropertiesEditorCallback('hide editor');
                return;
            } else if (event.keyCode === 83 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event.shiftKey || window.chrome || window.opera)) {
                event.preventDefault();
                if (event.stopImmediatePropagation) {
                    event.stopImmediatePropagation();
                } else {
                    event.stopPropagation();
                }


                updatePropertiesEditorCallback('save');
                return;
            }
            else if (event.keyCode === 81)
                console.log(editor);
            else if ((event.metaKey || event.ctrlKey) && event.key === 'c') {
                console.log('’Cmd+c’ was pressed')
                editor.trigger('source', 'editor.action.clipboardCopyAction');
            }
            else if ((event.metaKey || event.ctrlKey) && event.key === 'v') {
                console.log('’Cmd+v’ was pressed')
                editor.trigger('source', 'editor.action.clipboardPasteAction');
            }
            else if ((event.metaKey || event.ctrlKey) && event.key === 'x') {
                console.log('’Cmd+x’ was pressed')
                editor.trigger('source', 'editor.action.clipboardCutAction');
            }
 
        }, true);
        function updateText(txt) {
            console.log("should be updating the text");
            // Select all text
            alert(txt);
            const fullRange = editor.getModel().getFullModelRange();
            //                var lines = txt.split('\n');
            //                // remove one line, starting at the first position
            //                lines.splice(0,1);
            //                // join the array back into a single string
            //                txt = lines.join('\n').replace(/^ {2}/gm, '');

            // Apply the text over the range
            editor.executeEdits(null, [{
                text: txt,
                range: fullRange
            }]);

            // Indicates the above edit is a complete undo/redo change.
            editor.pushUndoStop();

            //editor.getModels()[0].setValue(txt);
            //editor.setValue(txt);
            //updatePropertiesCallback(JSON.parse(editor.getValue()));
            console.log(txt);
        }
    </script>
</body>

</html>
)xxx")
        };
    }
        
    static String getNewCabbageEffectFileText()
    {
        String newCsoundFile =
            "<Cabbage>\n"
            "form caption(\"Untitled\") size(400, 300), guiMode(\"queue\") pluginId(\"def1\")\n"
            "rslider bounds(296, 162, 100, 100), channel(\"gain\"), range(0, 1, 0, 1, .01), text(\"Gain\"), trackerColour(\"lime\"), outlineColour(0, 0, 0, 50), textColour(\"black\")\n"
            "\n"
            "</Cabbage>\n"
            "<CsoundSynthesizer>\n"
            "<CsOptions>\n"
            "-n -d\n"
            "</CsOptions>\n"
            "<CsInstruments>\n"
            "; Initialize the global variables. \n"
            "ksmps = 32\n"
            "nchnls = 2\n"
            "0dbfs = 1\n"
            "\n"
            "\n"
            "instr 1\n"
            "kGain cabbageGetValue \"gain\"\n"
            "\n"
            "a1 inch 1\n"
            "a2 inch 2\n"
            "\n"
            "outs a1*kGain, a2*kGain\n"
            "endin\n"
            "\n"
            "</CsInstruments>\n"
            "<CsScore>\n"
            ";causes Csound to run for about 7000 years...\n"
            "f0 z\n"
            ";starts instrument 1 and runs it for a week\n"
            "i1 0 [60*60*24*7] \n"
            "</CsScore>\n"
            "</CsoundSynthesizer>\n"
            "";

        return newCsoundFile;
    }

    static const StringArray getColourIDStrings()
    {
        StringArray colours;
        colours.add ("Interface - MenuBar Background");
        colours.add ("Interface - MenuBar Text");
        colours.add ("Interface - MenuBar MouseOver Background");
        colours.add ("Interface - PopupMenu MouseOver Background");
        colours.add ("Interface - PopupMenu Background");
        colours.add ("Interface - PopupMenu Text");
        colours.add ("Interface - PopupMenu Highlighted Text");
        colours.add ("Interface - Main Background");
        colours.add ("Interface - Status Bar");
        colours.add ("Interface - Status Bar Text");
        colours.add ("Interface - Property Panel Background");
        colours.add ("Interface - Property Label Background");
        colours.add ("Interface - Property Label Text");
        colours.add ("Interface - Alart Window Background");
		colours.add("Interface - File Tab Bar");
		colours.add("Interface - File Tab Button");
		colours.add("Interface - File Tab Text");
		colours.add("Interface - File Tab Play Button");
		colours.add("Interface - Patcher");
        colours.add ("Editor - Code Background");
        colours.add ("Editor - Line Numbers Background");
        colours.add ("Editor - Line Numbers");
        colours.add ("Editor - Selected Text Background");
        colours.add ("Editor - Caret");
        colours.add ("Editor - Identifier");
        colours.add ("Editor - Strings");
        colours.add ("Editor - Keyword");
        colours.add ("Editor - Comment");
        colours.add ("Editor - Numbers");
        colours.add ("Editor - Csd Tags");
        colours.add ("Editor - Scrollbars");
        colours.add ("Console - Text");
        colours.add ("Console - Background");
        colours.add ("Console - Outline");
        return colours;
    }
};

static const StringArray getOpcodeHints(){
    StringArray opcodes = {
        "\"0dbfs\";\"Orchestra Syntax:Header\";\"Sets the value of 0 decibels using full scale amplitude.\";\"0dbfs = iarg\"",
        "\"kr\";\"Orchestra Syntax:Header\";\"Sets the control rate.\";\"kr = iarg\"",
        "\"ksmps\";\"Orchestra Syntax:Header\";\"Sets the number of samples in a control period.\";\"ksmps = iarg\"",
        "\"nchnls\";\"Orchestra Syntax:Header\";\"Sets the number of channels of audio output.\";\"nchnls = iarg\"",
        "\"nchnls_i\";\"Orchestra Syntax:Header\";\"Sets the number of channels of audio input.\";\"nchnls_i = iarg\"",
        "\"sr\";\"Orchestra Syntax:Header\";\"Sets the audio sampling rate.\";\"sr = iarg\"",
        "\"endin\";\"Orchestra Syntax:Block Statements\";\"Ends the current instrument block.\";\"endin\"",
        "\"endop\";\"Orchestra Syntax:Block Statements\";\"Marks the end of an user-defined opcode block.\";\"endop\"",
        "\"instr\";\"Orchestra Syntax:Block Statements\";\"Starts an instrument block.\";\"instr i, j, ...\"",
        "\"opcode\";\"Orchestra Syntax:Block Statements\";\"Defines the start of user-defined opcode block.\";\"opcode name, outtypes, intypes\"",
        "\"#define\";\"Orchestra Syntax:Macros\";\"Defines a macro.\";\"#define NAME # replacement text #\"",
        "\"$NAME\";\"Orchestra Syntax:Macros\";\"Calls a defined macro.\";\"$NAME\"",
        "\"#ifdef\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#ifdef NAME\"",
        "\"#else\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#else\"",
        "\"#end\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#end\"",
        "\"#ifndef\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#ifndef NAME\"",
        "\"#else\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#else\"",
        "\"#end\";\"Orchestra Syntax:Macros\";\"Conditional reading of code.\";\"#end\"",
        "\"#include\";\"Orchestra Syntax:Macros\";\"Includes an external file for processing.\";\"#include \"filename\"\"",
        "\"#undef\";\"Orchestra Syntax:Macros\";\"Un-defines a macro.\";\"#undef NAME\"",
        "\"adsyn\";\"Signal Generators:Additive Synthesis/Resynthesis\";\"Output is an additive set of individually controlled sinusoids, using an oscillator bank.\";\"ares adsyn kamod, kfmod, ksmod, ifilcod\"",
        "\"adsynt\";\"Signal Generators:Additive Synthesis/Resynthesis\";\"Performs additive synthesis with an arbitrary number of partials, not necessarily harmonic.\";\"ares adsynt kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs]\"",
        "\"adsynt2\";\"Signal Generators:Additive Synthesis/Resynthesis\";\"Performs additive synthesis with an arbitrary number of partials -not necessarily harmonic- with interpolation.\";\"ar adsynt2 kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs]\"",
        "\"hsboscil\";\"Signal Generators:Additive Synthesis/Resynthesis\";\"An oscillator which takes tonality and brightness as arguments.\";\"ares hsboscil kamp, ktone, kbrite, ibasfreq, iwfn, ioctfn  [, ioctcnt] [, iphs]\"",
        "\"lfo\";\"Signal Generators:Basic Oscillators\";\"A low frequency oscillator of various shapes.\";\"kres lfo kamp, kcps [, itype]\"",
        "\"oscbnk\";\"Signal Generators:Basic Oscillators\";\"Mixes the output of any number of oscillators.\";\"ares oscbnk kcps, kamd, kfmd, kpmd, iovrlap, iseed, kl1minf, kl1maxf,  kl2minf, kl2maxf, ilfomode, keqminf, keqmaxf, keqminl, keqmaxl,  keqminq, keqmaxq, ieqmode, kfn [, il1fn] [, il2fn] [, ieqffn]  [, ieqlfn] [, ieqqfn] [, itabl] [, ioutfn]\"",
        "\"oscil\";\"Signal Generators:Basic Oscillators\";\"A simple oscillator.\";\"ares oscil xamp, xcps, ifn [, iphs]\"",
        "\"oscil3\";\"Signal Generators:Basic Oscillators\";\"A simple oscillator with cubic interpolation.\";\"ares oscil3 xamp, xcps, ifn [, iphs]\"",
        "\"oscili\";\"Signal Generators:Basic Oscillators\";\"A simple oscillator with linear interpolation.\";\"ares oscili xamp, xcps, ifn [, iphs]\"",
        "\"oscilikt\";\"Signal Generators:Basic Oscillators\";\"A linearly interpolated oscillator that allows changing the table number at k-rate.\";\"ares oscilikt xamp, xcps, kfn [, iphs] [, istor]\"",
        "\"osciliktp\";\"Signal Generators:Basic Oscillators\";\"A linearly interpolated oscillator that allows allows phase modulation.\";\"ares osciliktp kcps, kfn, kphs [, istor]\"",
        "\"oscilikts\";\"Signal Generators:Basic Oscillators\";\"A linearly interpolated oscillator with sync status that allows changing the table number at k-rate.\";\"ares oscilikts xamp, xcps, kfn, async, kphs [, istor]\"",
        "\"osciln\";\"Signal Generators:Basic Oscillators\";\"Accesses table values at a user-defined frequency.\";\"ares osciln kamp, ifrq, ifn, itimes\"",
        "\"oscilx\";\"Signal Generators:Basic Oscillators\";\"(same as osciln) Accesses table values at a user-defined frequency.\";\"ares osciln kamp, ifrq, ifn, itimes\"",
        "\"oscils\";\"Signal Generators:Basic Oscillators\";\"A simple, fast sine oscillator\";\"ares oscils iamp, icps, iphs [, iflg]\"",
        "\"poscil\";\"Signal Generators:Basic Oscillators\";\"High precision oscillator.\";\"ares poscil aamp, acps, ifn [, iphs]\"",
        "\"poscil3\";\"Signal Generators:Basic Oscillators\";\"High precision oscillator with cubic interpolation.\";\"ares poscil3 aamp, acps, ifn [, iphs]\"",
        "\"vibr\";\"Signal Generators:Basic Oscillators\";\"Easier-to-use user-controllable vibrato.\";\"kout vibr kAverageAmp, kAverageFreq, ifn\"",
        "\"vibrato\";\"Signal Generators:Basic Oscillators\";\"Generates a natural-sounding user-controllable vibrato.\";\"kout vibrato kAverageAmp, kAverageFreq, kRandAmountAmp, kRandAmountFreq, kAmpMinRate, kAmpMaxRate, kcpsMinRate, kcpsMaxRate, ifn [, iphs\"",
        "\"buzz\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Output is a set of harmonically related sine partials.\";\"ares buzz xamp, xcps, knh, ifn [, iphs]\"",
        "\"gbuzz\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Output is a set of harmonically related cosine partials.\";\"ares gbuzz xamp, xcps, knh, klh, kmul, ifn [, iphs]\"",
        "\"mpulse\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Generates a set of impulses.\";\"ares mpulse kamp, kintvl [, ioffset]\"",
        "\"vco\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Implementation of a band limited, analog modeled oscillator.\";\"ares vco xamp, xcps, iwave, kpw [, ifn] [, imaxd] [, ileak] [, inyx]  [, iphs] [, iskip]\"",
        "\"vco2\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Implementation of a band-limited oscillator using pre-calculated tables.\";\"ares vco2 kamp, kcps [, imode] [, kpw] [, kphs] [, inyx]\"",
        "\"vco2ft\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Returns a table number at k-time for a given oscillator frequency and wavform.\";\"kfn vco2ft kcps, iwave [, inyx]\"",
        "\"vco2ift\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Returns a table number at i-time for a given oscillator frequency and wavform.\";\"ifn vco2ift icps, iwave [, inyx]\"",
        "\"vco2init\";\"Signal Generators:Dynamic Spectrum Oscillators\";\"Calculates tables for use by vco2 opcode.\";\"ifn vco2init iwave [, ibasfn] [, ipmul] [, iminsiz] [, imaxsiz] [, isrcft]\"",
        "\"crossfm\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crossfm xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"crossfmi\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crossfmi xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"crosspm\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crosspm xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"crosspmi\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crosspmi xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"crossfmpm\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crossfmpm xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"crossfmpmi\";\"Signal Generators:FM Synthesis\";\"Two mutually frequency and/or phase modulated oscillators.\";\"a1, a2 crossfmpmi xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]\"",
        "\"fmb3\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a Hammond B3 organ sound.\";\"ares fmb3 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3,  ifn4, ivfn\"",
        "\"fmbell\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a tublar bell sound.\";\"ares fmbell kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3,  ifn4, ivfn[, isus]\"",
        "\"fmmetal\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a\";\"ares fmmetal kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3,  ifn4, ivfn\"",
        "\"fmpercfl\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a percussive flute sound.\";\"ares fmpercfl kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2,  ifn3, ifn4, ivfn\"",
        "\"fmrhode\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a Fender Rhodes electric piano sound.\";\"ares fmrhode kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2,  ifn3, ifn4, ivfn\"",
        "\"fmvoice\";\"Signal Generators:FM Synthesis\";\"FM Singing Voice Synthesis\";\"ares fmvoice kamp, kfreq, kvowel, ktilt, kvibamt, kvibrate, ifn1,  ifn2, ifn3, ifn4, ivibfn\"",
        "\"fmwurlie\";\"Signal Generators:FM Synthesis\";\"Uses FM synthesis to create a Wurlitzer electric piano sound.\";\"ares fmwurlie kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3,  ifn4, ivfn\"",
        "\"foscil\";\"Signal Generators:FM Synthesis\";\"A basic frequency modulated oscillator.\";\"ares foscil xamp, kcps, xcar, xmod, kndx, ifn [, iphs]\"",
        "\"foscili\";\"Signal Generators:FM Synthesis\";\"Basic frequency modulated oscillator with linear interpolation.\";\"ares foscili xamp, kcps, xcar, xmod, kndx, ifn [, iphs]\"",
        "\"diskgrain\";\"Signal Generators:Granular Synthesis\";\"Synchronous granular synthesis, using a soundfile as source.\";\"asig diskgrain Sfname, kamp, kfreq, kpitch, kgrsize, kprate,  ifun, iolaps [,imaxgrsize , ioffset]\"",
        "\"fof\";\"Signal Generators:Granular Synthesis\";\"Produces sinusoid bursts useful for formant and granular synthesis.\";\"ares fof xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps,  ifna, ifnb, itotdur [, iphs] [, ifmode] [, iskip]\"",
        "\"fof2\";\"Signal Generators:Granular Synthesis\";\"Produces sinusoid bursts including k-rate incremental indexing with each successive burst.\";\"ares fof2 xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps,  ifna, ifnb, itotdur, kphs, kgliss [, iskip]\"",
        "\"fog\";\"Signal Generators:Granular Synthesis\";\"Audio output is a succession of grains derived from data in a stored function table\";\"ares fog xamp, xdens, xtrans, aspd, koct, kband, kris, kdur, kdec,  iolaps, ifna, ifnb, itotdur [, iphs] [, itmode] [, iskip]\"",
        "\"grain\";\"Signal Generators:Granular Synthesis\";\"Generates granular synthesis textures.\";\"ares grain xamp, xpitch, xdens, kampoff, kpitchoff, kgdur, igfn,  iwfn, imgdur [, igrnd]\"",
        "\"grain2\";\"Signal Generators:Granular Synthesis\";\"Easy-to-use granular synthesis texture generator.\";\"ares grain2 kcps, kfmd, kgdur, iovrlp, kfn, iwfn [, irpow]  [, iseed] [, imode]\"",
        "\"grain3\";\"Signal Generators:Granular Synthesis\";\"Generate granular synthesis textures with more user control.\";\"ares grain3 kcps, kphs, kfmd, kpmd, kgdur, kdens, imaxovr, kfn, iwfn,  kfrpow, kprpow [, iseed] [, imode]\"",
        "\"granule\";\"Signal Generators:Granular Synthesis\";\"A more complex granular synthesis texture generator.\";\"ares granule xamp, ivoice, iratio, imode, ithd, ifn, ipshift, igskip,  igskip_os, ilength, kgap, igap_os, kgsize, igsize_os, iatt, idec  [, iseed] [, ipitch1] [, ipitch2] [, ipitch3] [, ipitch4] [, ifnenv]\"",
        "\"partikkel\";\"Signal Generators:Granular Synthesis\";\"Granular synthesizer with \"per grain\" control over many of its parameters. Has a sync input to sychronize its internal grain scheduler clock to an external clock source.\";\"a1 [, a2, a3, a4, a5, a6, a7, a8] partikkel agrainfreq,  kdistribution, idisttab, async, kenv2amt, ienv2tab, ienv_attack,  ienv_decay, ksustain_amount, ka_d_ratio, kduration, kamp, igainmasks,  kwavfreq, ksweepshape, iwavfreqstarttab, iwavfreqendtab, awavfm,  ifmamptab, kfmenv, icosine, ktraincps, knumpartials, kchroma,  ichannelmasks, krandommask, kwaveform1, kwaveform2, kwaveform3,  kwaveform4, iwaveamptab, asamplepos1, asamplepos2, asamplepos3,  asamplepos4, kwavekey1, kwavekey2, kwavekey3, kwavekey4, imax_grains  [, iopcode_id]\"",
        "\"partikkelsync\";\"Signal Generators:Granular Synthesis\";\"Outputs\";\"async [,aphase] partikkelsync iopcode_id\"",
        "\"sndwarp\";\"Signal Generators:Granular Synthesis\";\"Reads a mono sound sample from a table and applies time-stretching and/or pitch modification.\";\"ares [, ac] sndwarp xamp, xtimewarp, xresample, ifn1, ibeg, iwsize,  irandw, ioverlap, ifn2, itimemode\"",
        "\"sndwarpst\";\"Signal Generators:Granular Synthesis\";\"Reads a stereo sound sample from a table and applies time-stretching and/or pitch modification.\";\"ar1, ar2 [,ac1] [, ac2] sndwarpst xamp, xtimewarp, xresample, ifn1,  ibeg, iwsize, irandw, ioverlap, ifn2, itimemode\"",
        "\"syncgrain\";\"Signal Generators:Granular Synthesis\";\"Synchronous granular synthesis.\";\"asig syncgrain kamp, kfreq, kpitch, kgrsize, kprate, ifun1,  ifun2, iolaps\"",
        "\"syncloop\";\"Signal Generators:Granular Synthesis\";\"Synchronous granular synthesis.\";\"asig syncloop kamp, kfreq, kpitch, kgrsize, kprate, klstart,  klend, ifun1, ifun2, iolaps[,istart, iskip]\"",
        "\"vosim\";\"Signal Generators:Granular Synthesis\";\"Simple vocal simulation based on glottal pulses with formant characteristics.\";\"ar vosim kamp, kFund, kForm, kDecay, kPulseCount, kPulseFactor, ifn [, iskip]\"",
        "\"hvs1\";\"Signal Generators:Hyper Vectorial Synthesis\";\"Allows one-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.\";\"hvs1 kx, inumParms, inumPointsX, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]\"",
        "\"hvs2\";\"Signal Generators:Hyper Vectorial Synthesis\";\"Allows two-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.\";\"hvs2 kx, ky, inumParms, inumPointsX, inumPointsY, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]\"",
        "\"hvs3\";\"Signal Generators:Hyper Vectorial Synthesis\";\"Allows three-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.\";\"hvs3 kx, ky, kz, inumParms, inumPointsX, inumPointsY, inumPointsZ, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]\"",
        "\"expcurve\";\"Signal Generators:Linear and Exponential Generators\";\"This opcode implements a formula for generating a normalised exponential curve in range 0 - 1. It is based on the Max / MSP work of Eric Singer (c) 1994.\";\"kout expcurve kindex, ksteepness\"",
        "\"expon\";\"Signal Generators:Linear and Exponential Generators\";\"Trace an exponential curve between specified points.\";\"ares expon ia, idur, ib\"",
        "\"expseg\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of exponential segments between specified points.\";\"ares expseg ia, idur1, ib [, idur2] [, ic] [...]\"",
        "\"expsega\";\"Signal Generators:Linear and Exponential Generators\";\"An exponential segment generator operating at a-rate.\";\"ares expsega ia, idur1, ib [, idur2] [, ic] [...]\"",
        "\"expsegb\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of exponential segments between specified absolute points.\";\"ares expsegb ia, itim1, ib [, itim2] [, ic] [...]\"",
        "\"expsegba\";\"Signal Generators:Linear and Exponential Generators\";\"An exponential segment generator operating at a-rate with absolute times.\";\"ares expsegba ia, itim1, ib [, itim2] [, ic] [...]\"",
        "\"expsegr\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of exponential segments between specified points including a release segment.\";\"ares expsegr ia, idur1, ib [, idur2] [, ic] [...], irel, iz\"",
        "\"gainslider\";\"Signal Generators:Linear and Exponential Generators\";\"An implementation of a logarithmic gain curve which is similar to the gainslider~ object from Cycling 74 Max / MSP.\";\"kout gainslider kindex\"",
        "\"jspline\";\"Signal Generators:Linear and Exponential Generators\";\"A jitter-spline generator.\";\"ares jspline xamp, kcpsMin, kcpsMax\"",
        "\"line\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a straight line between specified points.\";\"ares line ia, idur, ib\"",
        "\"linseg\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of line segments between specified points.\";\"ares linseg ia, idur1, ib [, idur2] [, ic] [...]\"",
        "\"linsegb\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of line segments between specified absolute points.\";\"ares linsegb ia, itim1, ib [, itim2] [, ic] [...]\"",
        "\"linsegr\";\"Signal Generators:Linear and Exponential Generators\";\"Trace a series of line segments between specified points including a release segment.\";\"ares linsegr ia, idur1, ib [, idur2] [, ic] [...], irel, iz\"",
        "\"logcurve\";\"Signal Generators:Linear and Exponential Generators\";\"This opcode implements a formula for generating a normalised logarithmic curve in range 0 - 1. It is based on the Max / MSP work of Eric Singer (c) 1994.\";\"kout logcurve kindex, ksteepness\"",
        "\"loopseg\";\"Signal Generators:Linear and Exponential Generators\";\"Generate control signal consisting of linear segments delimited by two or more specified points.\";\"ksig loopseg kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1]  [, ktime2] [, kvalue2] [...]\"",
        "\"loopsegp\";\"Signal Generators:Linear and Exponential Generators\";\"Control signals based on linear segments.\";\"ksig loopsegp kphase, kvalue0, kdur0, kvalue1  [, kdur1, ... , kdurN-1, kvalueN]\"",
        "\"looptseg\";\"Signal Generators:Linear and Exponential Generators\";\"Generate control signal consisting of exponential or linear segments delimited by two or more specified points.\";\"ksig looptseg kfreq, ktrig, ktime0, kvalue0, ktype0, [, ktime1] [, kvalue1] [,ktype1]  [, ktime2] [, kvalue2] [,ktype2] [...]\"",
        "\"loopxseg\";\"Signal Generators:Linear and Exponential Generators\";\"Generate control signal consisting of exponential segments delimited by two or more specified points.\";\"ksig loopxseg kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1]  [, ktime2] [, kvalue2] [...]\"",
        "\"lpshold\";\"Signal Generators:Linear and Exponential Generators\";\"Generate control signal consisting of held segments.\";\"ksig lpshold kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1]  [, ktime2] [, kvalue2] [...]\"",
        "\"lpsholdp\";\"Signal Generators:Linear and Exponential Generators\";\"Control signals based on held segments.\";\"ksig lpsholdp kphase, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1]  [, ktime2] [, kvalue2] [...]\"",
        "\"rspline\";\"Signal Generators:Linear and Exponential Generators\";\"Generate random spline curves.\";\"ares rspline xrangeMin, xrangeMax, kcpsMin, kcpsMax\"",
        "\"scale\";\"Signal Generators:Linear and Exponential Generators\";\"Arbitrary signal scaling.\";\"kscl scale kinput, kmax, kmin\"",
        "\"transeg\";\"Signal Generators:Linear and Exponential Generators\";\"Constructs a user-definable envelope.\";\"ares transeg ia, idur, itype, ib [, idur2] [, itype] [, ic] ...\"",
        "\"transegb\";\"Signal Generators:Linear and Exponential Generators\";\"Constructs a user-definable envelope in absolute time.\";\"ares transegb ia, itim, itype, ib [, itim2] [, itype] [, ic] ...\"",
        "\"transegr\";\"Signal Generators:Linear and Exponential Generators\";\"Constructs a user-definable envelope with extended release segment.\";\"ares transegr ia, idur, itype, ib [, idur2] [, itype] [, ic] ...\"",
        "\"adsr\";\"Signal Generators:Envelope Generators\";\"Calculates the classical ADSR envelope using linear segments.\";\"ares adsr iatt, idec, islev, irel [, idel]\"",
        "\"envlpx\";\"Signal Generators:Envelope Generators\";\"Applies an envelope consisting of 3 segments.\";\"ares envlpx xamp, irise, idur, idec, ifn, iatss, iatdec [, ixmod]\"",
        "\"envlpxr\";\"Signal Generators:Envelope Generators\";\"The\";\"ares envlpxr xamp, irise, idec, ifn, iatss, iatdec [, ixmod] [,irind]\"",
        "\"linen\";\"Signal Generators:Envelope Generators\";\"Applies a straight line rise and decay pattern to an input amp signal.\";\"ares linen xamp, irise, idur, idec\"",
        "\"linenr\";\"Signal Generators:Envelope Generators\";\"The\";\"ares linenr xamp, irise, idec, iatdec\"",
        "\"madsr\";\"Signal Generators:Envelope Generators\";\"Calculates the classical ADSR envelope using the\";\"ares madsr iatt, idec, islev, irel [, idel] [, ireltim]\"",
        "\"mxadsr\";\"Signal Generators:Envelope Generators\";\"Calculates the classical ADSR envelope using the\";\"ares mxadsr iatt, idec, islev, irel [, idel] [, ireltim]\"",
        "\"xadsr\";\"Signal Generators:Envelope Generators\";\"Calculates the classical ADSR envelope.\";\"ares xadsr iatt, idec, islev, irel [, idel]\"",
        "\"bamboo\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a bamboo sound.\";\"ares bamboo kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq]  [, ifreq1] [, ifreq2]\"",
        "\"barmodel\";\"Signal Generators:Models and Emulations\";\"Creates a tone similar to a struck metal bar.\";\"ares barmodel kbcL, kbcR, iK, ib, kscan, iT30, ipos, ivel, iwid\"",
        "\"cabasa\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a cabasa sound.\";\"ares cabasa iamp, idettack [, inum] [, idamp] [, imaxshake]\"",
        "\"chuap\";\"Signal Generators:Models and Emulations\";\"Simulates Chua's oscillator, an LRC oscillator with an active resistor, proved capable of bifurcation and chaotic attractors, with k-rate control of circuit elements.\";\"aI3, aV2, aV1 chuap kL, kR0, kC1, kG, kGa, kGb, kE, kC2, iI3, iV2, iV1, ktime_step\"",
        "\"crunch\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a crunch sound.\";\"ares crunch iamp, idettack [, inum] [, idamp] [, imaxshake]\"",
        "\"dripwater\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a water drop.\";\"ares dripwater kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq]  [, ifreq1] [, ifreq2]\"",
        "\"gendy\";\"Signal Generators:Models and Emulations\";\"Dynamic stochastic approach to waveform synthesis conceived by Iannis Xenakis.\";\"ares gendy kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq,  kampscl, kdurscl [, initcps] [, knum]\"",
        "\"gendyc\";\"Signal Generators:Models and Emulations\";\"Dynamic stochastic approach to waveform synthesis using cubic interpolation.\";\"ares gendyc kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq,  kampscl, kdurscl [, initcps] [, knum]\"",
        "\"gendyx\";\"Signal Generators:Models and Emulations\";\"Variation of the dynamic stochastic approach to waveform synthesis conceived by Iannis Xenakis.\";\"ares gendyx kamp, kampdist, kdurdist, kadpar, kddpar, kminfreq, kmaxfreq,  kampscl, kdurscl, kcurveup, kcurvedown [, initcps] [, knum]\"",
        "\"gogobel\";\"Signal Generators:Models and Emulations\";\"Audio output is a tone related to the striking of a cow bell or similar.\";\"ares gogobel kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivfn\"",
        "\"guiro\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a guiro sound.\";\"ares guiro kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1]\"",
        "\"lorenz\";\"Signal Generators:Models and Emulations\";\"Implements the Lorenz system of equations.\";\"ax, ay, az lorenz ksv, krv, kbv, kh, ix, iy, iz, iskip [, iskipinit]\"",
        "\"mandel\";\"Signal Generators:Models and Emulations\";\"Mandelbrot set\";\"kiter, koutrig mandel ktrig, kx, ky, kmaxIter\"",
        "\"mandol\";\"Signal Generators:Models and Emulations\";\"An emulation of a mandolin.\";\"ares mandol kamp, kfreq, kpluck, kdetune, kgain, ksize, ifn [, iminfreq]\"",
        "\"marimba\";\"Signal Generators:Models and Emulations\";\"Physical model related to the striking of a wooden block.\";\"ares marimba kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec  [, idoubles] [, itriples]\"",
        "\"moog\";\"Signal Generators:Models and Emulations\";\"An emulation of a mini-Moog synthesizer.\";\"ares moog kamp, kfreq, kfiltq, kfiltrate, kvibf, kvamp, iafn, iwfn, ivfn\"",
        "\"planet\";\"Signal Generators:Models and Emulations\";\"Simulates a planet orbiting in a binary star system.\";\"ax, ay, az planet kmass1, kmass2, ksep, ix, iy, iz, ivx, ivy, ivz, idelta  [, ifriction] [, iskip]\"",
        "\"prepiano\";\"Signal Generators:Models and Emulations\";\"Creates a tone similar to a piano string prepared in a Cageian fashion.\";\"ares prepiano ifreq, iNS, iD, iK,  iT30,iB, kbcl, kbcr, imass, ifreq, iinit, ipos, ivel, isfreq,  isspread[, irattles, irubbers]\"",
        "\"sandpaper\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a sandpaper sound.\";\"ares sandpaper iamp, idettack [, inum] [, idamp] [, imaxshake]\"",
        "\"sekere\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a sekere sound.\";\"ares sekere iamp, idettack [, inum] [, idamp] [, imaxshake]\"",
        "\"shaker\";\"Signal Generators:Models and Emulations\";\"Sounds like the shaking of a maraca or similar gourd instrument.\";\"ares shaker kamp, kfreq, kbeans, kdamp, ktimes [, idecay]\"",
        "\"sleighbells\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a sleighbell sound.\";\"ares sleighbells kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq]  [, ifreq1] [, ifreq2]\"",
        "\"stix\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a stick sound.\";\"ares stix iamp, idettack [, inum] [, idamp] [, imaxshake]\"",
        "\"tambourine\";\"Signal Generators:Models and Emulations\";\"Semi-physical model of a tambourine sound.\";\"ares tambourine kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq]  [, ifreq1] [, ifreq2]\"",
        "\"vibes\";\"Signal Generators:Models and Emulations\";\"Physical model related to the striking of a metal block.\";\"ares vibes kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec\"",
        "\"voice\";\"Signal Generators:Models and Emulations\";\"An emulation of a human voice.\";\"ares voice kamp, kfreq, kphoneme, kform, kvibf, kvamp, ifn, ivfn\"",
        "\"phasor\";\"Signal Generators:Phasors\";\"Produce a normalized moving phase value.\";\"ares phasor xcps [, iphs]\"",
        "\"phasorbnk\";\"Signal Generators:Phasors\";\"Produce an arbitrary number of normalized moving phase values.\";\"ares phasorbnk xcps, kndx, icnt [, iphs]\"",
        "\"syncphasor\";\"Signal Generators:Phasors\";\"Produces a normalized moving phase value with sync input and output.\";\"aphase, asyncout syncphasor xcps, asyncin, [, iphs]\"",
        "\"betarand\";\"Signal Generators:Random (Noise) Generators\";\"Beta distribution random number generator (positive values only).\";\"ares betarand krange, kalpha, kbeta\"",
        "\"bexprnd\";\"Signal Generators:Random (Noise) Generators\";\"Exponential distribution random number generator.\";\"ares bexprnd krange\"",
        "\"cauchy\";\"Signal Generators:Random (Noise) Generators\";\"Cauchy distribution random number generator.\";\"ares cauchy kalpha\"",
        "\"cauchyi\";\"Signal Generators:Random (Noise) Generators\";\"Cauchy distribution random number generator with interpolation.\";\"ares cauchyi klambda, xamp, xcps\"",
        "\"cuserrnd\";\"Signal Generators:Random (Noise) Generators\";\"Continuous USER-defined-distribution RaNDom generator.\";\"aout cuserrnd kmin, kmax, ktableNum\"",
        "\"duserrnd\";\"Signal Generators:Random (Noise) Generators\";\"Discrete USER-defined-distribution RaNDom generator.\";\"aout duserrnd ktableNum\"",
        "\"dust\";\"Signal Generators:Random (Noise) Generators\";\"Random impulses.\";\"ares dust kamp, kdensity\"",
        "\"dust2\";\"Signal Generators:Random (Noise) Generators\";\"Random impulses.\";\"ares dust2 kamp, kdensity\"",
        "\"exprand\";\"Signal Generators:Random (Noise) Generators\";\"Exponential distribution random number generator (positive values only).\";\"ares exprand klambda\"",
        "\"exprandi\";\"Signal Generators:Random (Noise) Generators\";\"Exponential distribution random number generator with interpolation (positive values only).\";\"ares exprandi klambda, xamp, xcps\"",
        "\"fractalnoise\";\"Signal Generators:Random (Noise) Generators\";\"A fractal noise generator.\";\"ares fractalnoise kamp, kbeta\"",
        "\"gauss\";\"Signal Generators:Random (Noise) Generators\";\"Gaussian distribution random number generator.\";\"ares gauss krange\"",
        "\"gaussi\";\"Signal Generators:Random (Noise) Generators\";\"Gaussian distribution random number generator with interpolation.\";\"ares gaussi krange, xamp, xcps\"",
        "\"gausstrig\";\"Signal Generators:Random (Noise) Generators\";\"Random impulses around a certain frequency.\";\"ares gausstrig kamp, kcps, kdev [, imode]\"",
        "\"jitter\";\"Signal Generators:Random (Noise) Generators\";\"Generates a segmented line whose segments are randomly generated.\";\"kout jitter kamp, kcpsMin, kcpsMax\"",
        "\"jitter2\";\"Signal Generators:Random (Noise) Generators\";\"Generates a segmented line with user-controllable random segments.\";\"kout jitter2 ktotamp, kamp1, kcps1, kamp2, kcps2, kamp3, kcps3\"",
        "\"linrand\";\"Signal Generators:Random (Noise) Generators\";\"Linear distribution random number generator (positive values only).\";\"ares linrand krange\"",
        "\"noise\";\"Signal Generators:Random (Noise) Generators\";\"A white noise generator with an IIR lowpass filter.\";\"ares noise xamp, kbeta\"",
        "\"pcauchy\";\"Signal Generators:Random (Noise) Generators\";\"Cauchy distribution random number generator (positive values only).\";\"ares pcauchy kalpha\"",
        "\"pinkish\";\"Signal Generators:Random (Noise) Generators\";\"Generates approximate pink noise.\";\"ares pinkish xin [, imethod] [, inumbands] [, iseed] [, iskip]\"",
        "\"poisson\";\"Signal Generators:Random (Noise) Generators\";\"Poisson distribution random number generator (positive values only).\";\"ares poisson klambda\"",
        "\"rand\";\"Signal Generators:Random (Noise) Generators\";\"Generates a controlled random number series.\";\"ares rand xamp [, iseed] [, isel] [, ioffset]\"",
        "\"randh\";\"Signal Generators:Random (Noise) Generators\";\"Generates random numbers and holds them for a period of time.\";\"ares randh xamp, xcps [, iseed] [, isize] [, ioffset]\"",
        "\"randi\";\"Signal Generators:Random (Noise) Generators\";\"Generates a controlled random number series with interpolation between each new number.\";\"ares randi xamp, xcps [, iseed] [, isize] [, ioffset]\"",
        "\"random\";\"Signal Generators:Random (Noise) Generators\";\"Generates a controlled pseudo-random number series between min and max values.\";\"ares random kmin, kmax\"",
        "\"randomh\";\"Signal Generators:Random (Noise) Generators\";\"Generates random numbers with a user-defined limit and holds them for a period of time.\";\"ares randomh kmin, kmax, xcps [,imode] [,ifirstval]\"",
        "\"randomi\";\"Signal Generators:Random (Noise) Generators\";\"Generates a user-controlled random number series with interpolation between each new number.\";\"ares randomi kmin, kmax, xcps [,imode] [,ifirstval]\"",
        "\"rnd31\";\"Signal Generators:Random (Noise) Generators\";\"31-bit bipolar random opcodes with controllable distribution.\";\"ax rnd31 kscl, krpow [, iseed]\"",
        "\"seed\";\"Signal Generators:Random (Noise) Generators\";\"Sets the global seed value.\";\"seed ival\"",
        "\"trandom\";\"Signal Generators:Random (Noise) Generators\";\"Generates a controlled pseudo-random number series between min and max values according to a trigger.\";\"kout trandom ktrig, kmin, kmax\"",
        "\"trirand\";\"Signal Generators:Random (Noise) Generators\";\"Triangular distribution random number generator\";\"ares trirand krange\"",
        "\"unirand\";\"Signal Generators:Random (Noise) Generators\";\"Uniform distribution random number generator (positive values only).\";\"ares unirand krange\"",
        "\"urandom\";\"Signal Generators:Random (Noise) Generators\";\"truly random opcodes with controllable range.\";\"ax urandom [imin, imax]\"",
        "\"urd\";\"Signal Generators:Random (Noise) Generators\";\"A discrete user-defined-distribution random generator that can be used as a function.\";\"aout = urd(ktableNum)\"",
        "\"weibull\";\"Signal Generators:Random (Noise) Generators\";\"Weibull distribution random number generator (positive values only).\";\"ares weibull ksigma, ktau\"",
        "\"bbcutm\";\"Signal Generators:Sample Playback\";\"Generates breakbeat-style cut-ups of a mono audio stream.\";\"a1 bbcutm asource, ibps, isubdiv, ibarlength, iphrasebars, inumrepeats  [, istutterspeed] [, istutterchance] [, ienvchoice ]\"",
        "\"bbcuts\";\"Signal Generators:Sample Playback\";\"Generates breakbeat-style cut-ups of a stereo audio stream.\";\"a1,a2 bbcuts asource1, asource2, ibps, isubdiv, ibarlength, iphrasebars,  inumrepeats [, istutterspeed] [, istutterchance] [, ienvchoice]\"",
        "\"flooper\";\"Signal Generators:Sample Playback\";\"Function-table-based crossfading looper.\";\"asig flooper kamp, kpitch, istart, idur, ifad, ifn\"",
        "\"flooper2\";\"Signal Generators:Sample Playback\";\"Function-table-based crossfading looper.\";\"asig flooper2 kamp, kpitch, kloopstart, kloopend, kcrossfade, ifn  [, istart, imode, ifenv, iskip]\"",
        "\"fluidAllOut\";\"Signal Generators:Sample Playback\";\"Collects all audio from all Fluidsynth engines in a performance\";\"aleft, aright fluidAllOut\"",
        "\"fluidCCi\";\"Signal Generators:Sample Playback\";\"Sends a MIDI controller data message to fluid.\";\"fluidCCi iEngineNumber, iChannelNumber, iControllerNumber, iValue\"",
        "\"fluidCCk\";\"Signal Generators:Sample Playback\";\"Sends a MIDI controller data message to fluid.\";\"fluidCCk iEngineNumber, iChannelNumber, iControllerNumber, kValue\"",
        "\"fluidControl\";\"Signal Generators:Sample Playback\";\"Sends MIDI note on, note off, and other messages to a SoundFont preset.\";\"fluidControl ienginenum, kstatus, kchannel, kdata1, kdata2\"",
        "\"fluidEngine\";\"Signal Generators:Sample Playback\";\"Instantiates a fluidsynth engine.\";\"ienginenum fluidEngine [iReverbEnabled] [, iChorusEnabled] [,iNumChannels] [, iPolyphony]\"",
        "\"fluidLoad\";\"Signal Generators:Sample Playback\";\"Loads a SoundFont into a fluidEngine, optionally listing SoundFont contents.\";\"isfnum fluidLoad soundfont, ienginenum[, ilistpresets]\"",
        "\"fluidNote\";\"Signal Generators:Sample Playback\";\"Plays a note on a channel in a fluidSynth engine.\";\"fluidNote ienginenum, ichannelnum, imidikey, imidivel\"",
        "\"fluidOut\";\"Signal Generators:Sample Playback\";\"Outputs sound from a given fluidEngine\";\"aleft, aright fluidOut ienginenum\"",
        "\"fluidProgramSelect\";\"Signal Generators:Sample Playback\";\"Assigns a preset from a SoundFont to a channel on a fluidEngine.\";\"fluidProgramSelect ienginenum, ichannelnum, isfnum, ibanknum, ipresetnum\"",
        "\"fluidSetInterpMethod\";\"Signal Generators:Sample Playback\";\"Set interpolation method for channel in Fluid Engine\";\"fluidSetInterpMethod ienginenum, ichannelnum, iInterpMethod\"",
        "\"loscil\";\"Signal Generators:Sample Playback\";\"Read sampled sound from a table.\";\"ar1 [,ar2] loscil xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1]  [, imod2] [, ibeg2] [, iend2]\"",
        "\"loscil3\";\"Signal Generators:Sample Playback\";\"Read sampled sound from a table using cubic interpolation.\";\"ar1 [,ar2] loscil3 xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1]  [, imod2] [, ibeg2] [, iend2]\"",
        "\"loscilx\";\"Signal Generators:Sample Playback\";\"Loop oscillator.\";\"ar1 [, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14,  ar15, ar16] loscilx xamp, kcps, ifn  [, iwsize, ibas, istrt, imod1, ibeg1, iend1]\"",
        "\"lphasor\";\"Signal Generators:Sample Playback\";\"Generates a table index for sample playback\";\"ares lphasor xtrns [, ilps] [, ilpe] [, imode] [, istrt] [, istor]\"",
        "\"lposcil\";\"Signal Generators:Sample Playback\";\"Read sampled sound from a table with looping and high precision.\";\"ares lposcil kamp, kfreqratio, kloop, kend, ifn [, iphs]\"",
        "\"lposcil3\";\"Signal Generators:Sample Playback\";\"Read sampled sound from a table with high precision and cubic interpolation.\";\"ares lposcil3 kamp, kfreqratio, kloop, kend, ifn [, iphs]\"",
        "\"lposcila\";\"Signal Generators:Sample Playback\";\"Read sampled sound from a table with looping and high precision.\";\"ar lposcila aamp, kfreqratio, kloop, kend, ift [,iphs]\"",
        "\"lposcilsa\";\"Signal Generators:Sample Playback\";\"Read stereo sampled sound from a table with looping and high precision.\";\"ar1, ar2 lposcilsa aamp, kfreqratio, kloop, kend, ift [,iphs]\"",
        "\"lposcilsa2\";\"Signal Generators:Sample Playback\";\"Read stereo sampled sound from a table with looping and high precision.\";\"ar1, ar2 lposcilsa2 aamp, kfreqratio, kloop, kend, ift [,iphs]\"",
        "\"sfilist\";\"Signal Generators:Sample Playback\";\"Prints a list of all instruments of a previously loaded SoundFont2 (SF2) file.\";\"sfilist ifilhandle\"",
        "\"sfinstr\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample instrument, generating a stereo sound.\";\"ar1, ar2 sfinstr ivel, inotenum, xamp, xfreq, instrnum, ifilhandle  [, iflag] [, ioffset]\"",
        "\"sfinstr3\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample instrument, generating a stereo sound with cubic interpolation.\";\"ar1, ar2 sfinstr3 ivel, inotenum, xamp, xfreq, instrnum, ifilhandle  [, iflag] [, ioffset]\"",
        "\"sfinstr3m\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample instrument, generating a mono sound with cubic interpolation.\";\"ares sfinstr3m ivel, inotenum, xamp, xfreq, instrnum, ifilhandle  [, iflag] [, ioffset]\"",
        "\"sfinstrm\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample instrument, generating a mono sound.\";\"ares sfinstrm ivel, inotenum, xamp, xfreq, instrnum, ifilhandle  [, iflag] [, ioffset]\"",
        "\"sfload\";\"Signal Generators:Sample Playback\";\"Loads an entire SoundFont2 (SF2) sample file into memory.\";\"ir sfload \"filename\"\"",
        "\"sflooper\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample preset, generating a stereo sound, with user-defined time-varying crossfade looping.\";\"ar1, ar2 sflooper ivel, inotenum, kamp, kpitch, ipreindex, kloopstart, kloopend, kcrossfade  [, istart, imode, ifenv, iskip]\"",
        "\"sfpassign\";\"Signal Generators:Sample Playback\";\"Assigns all presets of a SoundFont2 (SF2) sample file to a sequence of progressive index numbers.\";\"sfpassign istartindex, ifilhandle[, imsgs]\"",
        "\"sfplay\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample preset, generating a stereo sound.\";\"ar1, ar2 sfplay ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]\"",
        "\"sfplay3\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample preset, generating a stereo sound with cubic interpolation.\";\"ar1, ar2 sfplay3 ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]\"",
        "\"sfplay3m\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample preset, generating a mono sound with cubic interpolation.\";\"ares sfplay3m ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]\"",
        "\"sfplaym\";\"Signal Generators:Sample Playback\";\"Plays a SoundFont2 (SF2) sample preset, generating a mono sound.\";\"ares sfplaym ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]\"",
        "\"sfplist\";\"Signal Generators:Sample Playback\";\"Prints a list of all presets of a SoundFont2 (SF2) sample file.\";\"sfplist ifilhandle\"",
        "\"sfpreset\";\"Signal Generators:Sample Playback\";\"Assigns an existing preset of a SoundFont2 (SF2) sample file to an index number.\";\"ir sfpreset iprog, ibank, ifilhandle, ipreindex\"",
        "\"sndloop\";\"Signal Generators:Sample Playback\";\"A sound looper with pitch control.\";\"asig, krec sndloop ain, kpitch, ktrig, idur, ifad\"",
        "\"waveset\";\"Signal Generators:Sample Playback\";\"A simple time stretch by repeating cycles.\";\"ares waveset ain, krep [, ilen]\"",
        "\"scanhammer\";\"Signal Generators:Scanned Synthesis\";\"Copies from one table to another with a gain control.\";\"scanhammer isrc, idst, ipos, imult\"",
        "\"scans\";\"Signal Generators:Scanned Synthesis\";\"Generate audio output using scanned synthesis.\";\"ares scans kamp, kfreq, ifn, id [, iorder]\"",
        "\"scantable\";\"Signal Generators:Scanned Synthesis\";\"A simpler scanned synthesis implementation.\";\"aout scantable kamp, kpch, ipos, imass, istiff, idamp, ivel\"",
        "\"scanu\";\"Signal Generators:Scanned Synthesis\";\"Compute the waveform and the wavetable for use in scanned synthesis.\";\"scanu init, irate, ifnvel, ifnmass, ifnstif, ifncentr, ifndamp, kmass,  kstif, kcentr, kdamp, ileft, iright, kpos, kstrngth, ain, idisp, id\"",
        "\"xscanmap\";\"Signal Generators:Scanned Synthesis\";\"Allows the position and velocity of a node in a scanned process to be read.\";\"kpos, kvel xscanmap iscan, kamp, kvamp [, iwhich]\"",
        "\"xscans\";\"Signal Generators:Scanned Synthesis\";\"Fast scanned synthesis waveform and the wavetable generator.\";\"ares xscans kamp, kfreq, ifntraj, id [, iorder]\"",
        "\"xscansmap\";\"Signal Generators:Scanned Synthesis\";\"Allows the position and velocity of a node in a scanned process to be read.\";\"xscansmap kpos, kvel, iscan, kamp, kvamp [, iwhich]\"",
        "\"xscanu\";\"Signal Generators:Scanned Synthesis\";\"Compute the waveform and the wavetable for use in scanned synthesis.\";\"xscanu init, irate, ifnvel, ifnmass, ifnstif, ifncentr, ifndamp, kmass,  kstif, kcentr, kdamp, ileft, iright, kpos, kstrngth, ain, idisp, id\"",
        "\"STKBandedWG\";\"Signal Generators:STK Opcodes\";\"STKBandedWG uses banded waveguide techniques to model a variety of sounds.\";\"asignal STKBandedWG ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5[, kc6, kv6[, kc7, kv7]]]]]]]\"",
        "\"STKBeeThree\";\"Signal Generators:STK Opcodes\";\"STK Hammond-oid organ-like FM synthesis instrument.\";\"asignal STKBeeThree ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKBlowBotl\";\"Signal Generators:STK Opcodes\";\"STKBlowBotl uses a helmholtz resonator (biquad filter) with a polynomial jet excitation.\";\"asignal STKBlowBotl ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4]]]]\"",
        "\"STKBlowHole\";\"Signal Generators:STK Opcodes\";\"STK clarinet physical model with one register hole and one tonehole.\";\"asignal STKBlowHole ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKBowed\";\"Signal Generators:STK Opcodes\";\"STKBowed is a bowed string instrument.\";\"asignal STKBowed ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKBrass\";\"Signal Generators:STK Opcodes\";\"STKBrass is a simple brass instrument.\";\"asignal STKBrass ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKClarinet\";\"Signal Generators:STK Opcodes\";\"STKClarinet uses a simple clarinet physical model.\";\"asignal STKClarinet ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKDrummer\";\"Signal Generators:STK Opcodes\";\"STKDrummer is a drum sampling synthesizer.\";\"asignal STKDrummer ifrequency, iamplitude\"",
        "\"STKFMVoices\";\"Signal Generators:STK Opcodes\";\"STKFMVoices is a singing FM synthesis instrument.\";\"asignal STKFMVoices ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKFlute\";\"Signal Generators:STK Opcodes\";\"STKFlute uses a simple flute physical model.\";\"asignal STKFlute ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKHevyMetl\";\"Signal Generators:STK Opcodes\";\"STKHevyMetl produces metal sounds.\";\"asignal STKHevyMetl ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKMandolin\";\"Signal Generators:STK Opcodes\";\"STKMandolin produces mamdolin-like sounds.\";\"asignal STKMandolin ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKModalBar\";\"Signal Generators:STK Opcodes\";\"STKModalBar is a resonant bar instrument.\";\"asignal STKModalBar ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5[, kc6, kv6[, kc7, kv7]]]]]]]\"",
        "\"STKMoog\";\"Signal Generators:STK Opcodes\";\"STKMoog produces moog-like swept filter sounds.\";\"asignal STKMoog ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKPercFlut\";\"Signal Generators:STK Opcodes\";\"STKPercFlut is a percussive flute FM synthesis instrument.\";\"asignal STKPercFlut ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKPlucked\";\"Signal Generators:STK Opcodes\";\"STKPlucked uses a plucked string physical model.\";\"asignal STKPlucked ifrequency, iamplitude\"",
        "\"STKResonate\";\"Signal Generators:STK Opcodes\";\"STKResonate is a noise driven formant filter.\";\"asignal STKResonate ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKRhodey\";\"Signal Generators:STK Opcodes\";\"STK Fender Rhodes-like electric piano FM synthesis instrument.\";\"asignal STKRhodey ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKSaxofony\";\"Signal Generators:STK Opcodes\";\"STKSaxofony is a faux conical bore reed instrument.\";\"asignal STKSaxofony ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5[, kc6, kv6[, kc7, kv7]]]]]]]\"",
        "\"STKShakers\";\"Signal Generators:STK Opcodes\";\"STKShakers is an instrument that simulates environmental sounds or collisions of multiple independent sound producing objects.\";\"asignal STKShakers ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5[, kc6, kv6]]]]]]\"",
        "\"STKSimple\";\"Signal Generators:STK Opcodes\";\"STKSimple is a wavetable/noise instrument.\";\"asignal STKSimple ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4]]]]\"",
        "\"STKSitar\";\"Signal Generators:STK Opcodes\";\"STKSitar uses a plucked string physical model.\";\"asignal STKSitar ifrequency, iamplitude\"",
        "\"STKStifKarp\";\"Signal Generators:STK Opcodes\";\"STKStifKarp is a plucked stiff string instrument.\";\"asignal STKStifKarp ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3]]]\"",
        "\"STKTubeBell\";\"Signal Generators:STK Opcodes\";\"STKTubeBell is a tubular bell (orchestral chime) FM synthesis instrument.\";\"asignal STKTubeBell ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKVoicForm\";\"Signal Generators:STK Opcodes\";\"STKVoicForm is a four formant synthesis instrument.\";\"asignal STKVoicForm ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKWhistle\";\"Signal Generators:STK Opcodes\";\"STKWhistle produces whistle sounds.\";\"asignal STKWhistle ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"STKWurley\";\"Signal Generators:STK Opcodes\";\"STKWurley simulates a Wurlitzer electric piano FM synthesis instrument.\";\"asignal STKWurley ifrequency, iamplitude, [kc1, kv1[, kc2, kv2[, kc3, kv3[, kc4, kv4[, kc5, kv5]]]]]\"",
        "\"oscil1\";\"Signal Generators:Table Access\";\"Accesses table values by incremental sampling.\";\"kres oscil1 idel, kamp, idur, ifn\"",
        "\"oscil1i\";\"Signal Generators:Table Access\";\"Accesses table values by incremental sampling with linear interpolation.\";\"kres oscil1i idel, kamp, idur, ifn\"",
        "\"ptable\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing.\";\"ares ptable andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"ptable3\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing with cubic interpolation.\";\"ares ptable3 andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"ptablei\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing with linear interpolation.\";\"ares ptablei andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"tab_i\";\"Signal Generators:Table Access\";\"Fast table opcodes.\";\"ir tab_i indx, ifn[, ixmode]\"",
        "\"tab\";\"Signal Generators:Table Access\";\"Fast table opcodes.\";\"kr tab kndx, ifn[, ixmode]\"",
        "\"tabw_i\";\"Signal Generators:Table Access\";\"Fast table opcodes.\";\"tabw_i isig, indx, ifn [,ixmode]\"",
        "\"tabw\";\"Signal Generators:Table Access\";\"Fast table opcodes.\";\"tabw ksig, kndx, ifn [,ixmode]\"",
        "\"table\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing.\";\"ares table andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"table3\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing with cubic interpolation.\";\"ares table3 andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"tablei\";\"Signal Generators:Table Access\";\"Accesses table values by direct indexing with linear interpolation.\";\"ares tablei andx, ifn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"wterrain\";\"Signal Generators:Wave Terrain Synthesis\";\"A simple wave-terrain synthesis opcode.\";\"aout wterrain kamp, kpch, k_xcenter, k_ycenter, k_xradius, k_yradius,  itabx, itaby\"",
        "\"pluck\";\"Signal Generators:Waveguide Physical Modeling\";\"Produces a naturally decaying plucked string or drum sound.\";\"ares pluck kamp, kcps, icps, ifn, imeth [, iparm1] [, iparm2]\"",
        "\"repluck\";\"Signal Generators:Waveguide Physical Modeling\";\"Physical model of the plucked string.\";\"ares repluck iplk, kamp, icps, kpick, krefl, axcite\"",
        "\"streson\";\"Signal Generators:Waveguide Physical Modeling\";\"A string resonator with variable fundamental frequency.\";\"ares streson asig, kfr, ifdbgain\"",
        "\"wgbow\";\"Signal Generators:Waveguide Physical Modeling\";\"Creates a tone similar to a bowed string.\";\"ares wgbow kamp, kfreq, kpres, krat, kvibf, kvamp, ifn [, iminfreq]\"",
        "\"wgbowedbar\";\"Signal Generators:Waveguide Physical Modeling\";\"A physical model of a bowed bar.\";\"ares wgbowedbar kamp, kfreq, kpos, kbowpres, kgain [, iconst] [, itvel]  [, ibowpos] [, ilow]\"",
        "\"wgbrass\";\"Signal Generators:Waveguide Physical Modeling\";\"Creates a tone related to a brass instrument.\";\"ares wgbrass kamp, kfreq, ktens, iatt, kvibf, kvamp, ifn [, iminfreq]\"",
        "\"wgclar\";\"Signal Generators:Waveguide Physical Modeling\";\"Creates a tone similar to a clarinet.\";\"ares wgclar kamp, kfreq, kstiff, iatt, idetk, kngain, kvibf, kvamp, ifn  [, iminfreq]\"",
        "\"wgflute\";\"Signal Generators:Waveguide Physical Modeling\";\"Creates a tone similar to a flute.\";\"ares wgflute kamp, kfreq, kjet, iatt, idetk, kngain, kvibf, kvamp, ifn  [, iminfreq] [, ijetrf] [, iendrf]\"",
        "\"wgpluck\";\"Signal Generators:Waveguide Physical Modeling\";\"A high fidelity simulation of a plucked string.\";\"ares wgpluck icps, iamp, kpick, iplk, idamp, ifilt, axcite\"",
        "\"wgpluck2\";\"Signal Generators:Waveguide Physical Modeling\";\"Physical model of the plucked string.\";\"ares wgpluck2 iplk, kamp, icps, kpick, krefl\"",
        "\"dumpk\";\"Signal I/O:File I/O\";\"Periodically writes an orchestra control-signal value to an external file.\";\"dumpk ksig, ifilname, iformat, iprd\"",
        "\"dumpk2\";\"Signal I/O:File I/O\";\"Periodically writes two orchestra control-signal values to an external file.\";\"dumpk2 ksig1, ksig2, ifilname, iformat, iprd\"",
        "\"dumpk3\";\"Signal I/O:File I/O\";\"Periodically writes three orchestra control-signal values to an external file.\";\"dumpk3 ksig1, ksig2, ksig3, ifilname, iformat, iprd\"",
        "\"dumpk4\";\"Signal I/O:File I/O\";\"Periodically writes four orchestra control-signal values to an external file.\";\"dumpk4 ksig1, ksig2, ksig3, ksig4, ifilname, iformat, iprd\"",
        "\"ficlose\";\"Signal I/O:File I/O\";\"Closes a previously opened file.\";\"ficlose ihandle\"",
        "\"fin\";\"Signal I/O:File I/O\";\"Read signals from a file at a-rate.\";\"fin ifilename, iskipframes, iformat, ain1 [, ain2] [, ain3] [,...]\"",
        "\"fini\";\"Signal I/O:File I/O\";\"Read signals from a file at i-rate.\";\"fini ifilename, iskipframes, iformat, in1 [, in2] [, in3] [, ...]\"",
        "\"fink\";\"Signal I/O:File I/O\";\"Read signals from a file at k-rate.\";\"fink ifilename, iskipframes, iformat, kin1 [, kin2] [, kin3] [,...]\"",
        "\"fiopen\";\"Signal I/O:File I/O\";\"Opens a file in a specific mode.\";\"ihandle fiopen ifilename, imode\"",
        "\"fout\";\"Signal I/O:File I/O\";\"Outputs a-rate signals to an arbitrary number of channels.\";\"fout ifilename, iformat, aout1 [, aout2, aout3,...,aoutN]\"",
        "\"fouti\";\"Signal I/O:File I/O\";\"Outputs i-rate signals of an arbitrary number of channels to a specified file.\";\"fouti ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN]\"",
        "\"foutir\";\"Signal I/O:File I/O\";\"Outputs i-rate signals from an arbitrary number of channels to a specified file.\";\"foutir ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN]\"",
        "\"foutk\";\"Signal I/O:File I/O\";\"Outputs k-rate signals of an arbitrary number of channels to a specified file, in raw (headerless) format.\";\"foutk ifilename, iformat, kout1 [, kout2, kout3,....,koutN]\"",
        "\"fprintks\";\"Signal I/O:File I/O\";\"Similar to printks but prints to a file.\";\"fprintks \"filename\", \"string\", [, kval1] [, kval2] [...]\"",
        "\"fprints\";\"Signal I/O:File I/O\";\"Similar to prints but prints to a file.\";\"fprints \"filename\", \"string\" [, ival1] [, ival2] [...]\"",
        "\"readk\";\"Signal I/O:File I/O\";\"Periodically reads an orchestra control-signal value from an external file.\";\"kres readk ifilname, iformat, iprd\"",
        "\"readk2\";\"Signal I/O:File I/O\";\"Periodically reads two orchestra control-signal values from an external file.\";\"kr1, kr2 readk2 ifilname, iformat, iprd\"",
        "\"readk3\";\"Signal I/O:File I/O\";\"Periodically reads three orchestra control-signal values from an external file.\";\"kr1, kr2, kr3 readk3 ifilname, iformat, iprd\"",
        "\"readk4\";\"Signal I/O:File I/O\";\"Periodically reads four orchestra control-signal values from an external file.\";\"kr1, kr2, kr3, kr4 readk4 ifilname, iformat, iprd\"",
        "\"diskin\";\"Signal I/O:Signal Input\";\"Deprecated. Reads audio data from an external device or stream and can alter its pitch.\";\"ar1 [, ar2 [, ar3 [, ... arN]]] diskin ifilcod, kpitch [, iskiptim]  [, iwraparound] [, iformat] [, iskipinit]\"",
        "\"diskin2\";\"Signal I/O:Signal Input\";\"Reads audio data from a file, and can alter its pitch using one of several available interpolation types, as well as convert the sample rate to match the orchestra sr setting.\";\"a1[, a2[, ... aN]] diskin2 ifilcod, kpitch[, iskiptim  [, iwrap[, iformat [, iwsize[, ibufsize[, iskipinit]]]]]]\"",
        "\"in\";\"Signal I/O:Signal Input\";\"Reads mono audio data from an external device or stream.\";\"ar1 in\"",
        "\"in32\";\"Signal I/O:Signal Input\";\"Reads a 32-channel audio signal from an external device or stream.\";\"ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14,  ar15, ar16, ar17, ar18, ar19, ar20, ar21, ar22, ar23, ar24, ar25, ar26,  ar27, ar28, ar29, ar30, ar31, ar32 in32\"",
        "\"inch\";\"Signal I/O:Signal Input\";\"Reads from numbered channels in an external audio signal or stream.\";\"ain1[, ...] inch kchan1[,...]\"",
        "\"inh\";\"Signal I/O:Signal Input\";\"Reads six-channel audio data from an external device or stream.\";\"ar1, ar2, ar3, ar4, ar5, ar6 inh\"",
        "\"ino\";\"Signal I/O:Signal Input\";\"Reads eight-channel audio data from an external device or stream.\";\"ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8 ino\"",
        "\"inq\";\"Signal I/O:Signal Input\";\"Reads quad audio data from an external device or stream.\";\"ar1, ar2, ar3, a4 inq\"",
        "\"inrg\";\"Signal I/O:Signal Input\";\"Allow input from a range of adjacent audio channels from the audio input device\";\"inrg kstart, ain1 [,ain2, ain3, ..., ainN]\"",
        "\"ins\";\"Signal I/O:Signal Input\";\"Reads stereo audio data from an external device or stream.\";\"ar1, ar2 ins\"",
        "\"invalue\";\"Signal I/O:Signal Input\";\"Reads a k-rate signal from a user-defined channel.\";\"kvalue invalue \"channel name\"\"",
        "\"inx\";\"Signal I/O:Signal Input\";\"Reads a 16-channel audio signal from an external device or stream.\";\"ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12,  ar13, ar14, ar15, ar16 inx\"",
        "\"inz\";\"Signal I/O:Signal Input\";\"Reads multi-channel audio samples into a ZAK array from an external device or stream.\";\"inz ksig1\"",
        "\"mp3in\";\"Signal I/O:Signal Input\";\"Reads stereo audio data from an external MP3 file.\";\"ar1, ar2 mp3in ifilcod[, iskptim, iformat, iskipinit, ibufsize]\"",
        "\"soundin\";\"Signal I/O:Signal Input\";\"Reads audio data from an external device or stream.\";\"ar1[, ar2[, ar3[, ... a24]]] soundin ifilcod [, iskptim] [, iformat]  [, iskipinit] [, ibufsize]\"",
        "\"mdelay\";\"Signal I/O:Signal Output\";\"A MIDI delay opcode.\";\"mdelay kstatus, kchan, kd1, kd2, kdelay\"",
        "\"monitor\";\"Signal I/O:Signal Output\";\"Returns the audio spout frame.\";\"aout1 [,aout2 ... aoutX] monitor\"",
        "\"out\";\"Signal I/O:Signal Output\";\"Writes mono audio data to an external device or stream.\";\"out asig\"",
        "\"out32\";\"Signal I/O:Signal Output\";\"Writes 32-channel audio data to an external device or stream.\";\"out32 asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8, asig10,  asig11, asig12, asig13, asig14, asig15, asig16, asig17, asig18,  asig19, asig20, asig21, asig22, asig23, asig24, asig25, asig26,  asig27, asig28, asig29, asig30, asig31, asig32\"",
        "\"outc\";\"Signal I/O:Signal Output\";\"Writes audio data with an arbitrary number of channels to an external device or stream.\";\"outc asig1 [, asig2] [...]\"",
        "\"outch\";\"Signal I/O:Signal Output\";\"Writes multi-channel audio data, with user-controllable channels, to an external device or stream.\";\"outch kchan1, asig1 [, kchan2] [, asig2] [...]\"",
        "\"outh\";\"Signal I/O:Signal Output\";\"Writes 6-channel audio data to an external device or stream.\";\"outh asig1, asig2, asig3, asig4, asig5, asig6\"",
        "\"outo\";\"Signal I/O:Signal Output\";\"Writes 8-channel audio data to an external device or stream.\";\"outo asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8\"",
        "\"outq\";\"Signal I/O:Signal Output\";\"Writes 4-channel audio data to an external device or stream.\";\"outq asig1, asig2, asig3, asig4\"",
        "\"outq1\";\"Signal I/O:Signal Output\";\"Writes samples to quad channel 1 of an external device or stream.\";\"outq1 asig\"",
        "\"outq2\";\"Signal I/O:Signal Output\";\"Writes samples to quad channel 2 of an external device or stream.\";\"outq2 asig\"",
        "\"outq3\";\"Signal I/O:Signal Output\";\"Writes samples to quad channel 3 of an external device or stream.\";\"outq3 asig\"",
        "\"outq4\";\"Signal I/O:Signal Output\";\"Writes samples to quad channel 4 of an external device or stream.\";\"outq4 asig\"",
        "\"outrg\";\"Signal I/O:Signal Output\";\"Allow output to a range of adjacent audio channels on the audio output device\";\"outrg kstart, aout1 [,aout2, aout3, ..., aoutN]\"",
        "\"outs\";\"Signal I/O:Signal Output\";\"Writes stereo audio data to an external device or stream.\";\"outs asig1, asig2\"",
        "\"outs1\";\"Signal I/O:Signal Output\";\"Writes samples to stereo channel 1 of an external device or stream.\";\"outs1 asig\"",
        "\"outs2\";\"Signal I/O:Signal Output\";\"Writes samples to stereo channel 2 of an external device or stream.\";\"outs2 asig\"",
        "\"outvalue\";\"Signal I/O:Signal Output\";\"Sends a k-rate signal or string to a user-defined channel.\";\"outvalue \"channel name\", kvalue\"",
        "\"outx\";\"Signal I/O:Signal Output\";\"Writes 16-channel audio data to an external device or stream.\";\"outx asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8,  asig9, asig10, asig11, asig12, asig13, asig14, asig15, asig16\"",
        "\"outz\";\"Signal I/O:Signal Output\";\"Writes multi-channel audio data from a ZAK array to an external device or stream.\";\"outz ksig1\"",
        "\"soundout\";\"Signal I/O:Signal Output\";\"Deprecated. Writes audio output to a disk file.\";\"soundout asig1, ifilcod [, iformat]\"",
        "\"soundouts\";\"Signal I/O:Signal Output\";\"Deprecated. Writes audio output to a disk file.\";\"soundouts asigl, asigr, ifilcod [, iformat]\"",
        "\"chani\";\"Signal I/O:Software Bus\";\"Reads data from the software bus\";\"kval chani kchan\"",
        "\"chano\";\"Signal I/O:Software Bus\";\"Send data to the outwards software bus\";\"chano kval, kchan\"",
        "\"chn_k\";\"Signal I/O:Software Bus\";\"Declare a channel of the named software bus.\";\"chn_k Sname, imode[, itype, idflt, imin, imax]\"",
        "\"chn_a\";\"Signal I/O:Software Bus\";\"Declare a channel of the named software bus.\";\"chn_a Sname, imode\"",
        "\"chn_S\";\"Signal I/O:Software Bus\";\"Declare a channel of the named software bus.\";\"chn_S Sname, imode\"",
        "\"chnclear\";\"Signal I/O:Software Bus\";\"Clears an audio output channel of the named software bus.\";\"chnclear Sname\"",
        "\"chnexport\";\"Signal I/O:Software Bus\";\"Export a global variable as a channel of the bus.\";\"gival chnexport Sname, imode[, itype, idflt, imin, imax]\"",
        "\"chnget\";\"Signal I/O:Software Bus\";\"Reads data from the software bus.\";\"ival chnget Sname\"",
        "\"chnmix\";\"Signal I/O:Software Bus\";\"Writes audio data to the named software bus, mixing to the previous output.\";\"chnmix aval, Sname\"",
        "\"chnparams\";\"Signal I/O:Software Bus\";\"Query parameters of a channel.\";\"itype, imode, ictltype, idflt, imin, imax chnparams\"",
        "\"chnrecv\";\"Signal I/O:Software Bus\";\"Recieves data from the software bus.\";\"ival chnrecv Sname\"",
        "\"chnsend\";\"Signal I/O:Software Bus\";\"Sends data via the named software bus.\";\"chnsend ival, Sname\"",
        "\"chnset\";\"Signal I/O:Software Bus\";\"Writes data to the named software bus.\";\"chnset ival, Sname\"",
        "\"setksmps\";\"Signal I/O:Software Bus\";\"Sets the local ksmps value in a user-defined opcode block.\";\"setksmps iksmps\"",
        "\"xin\";\"Signal I/O:Software Bus\";\"Passes variables to a user-defined opcode block,\";\"xinarg1 [, xinarg2] ... [xinargN] xin\"",
        "\"xout\";\"Signal I/O:Software Bus\";\"Retrieves variables from a user-defined opcode block,\";\"xout xoutarg1 [, xoutarg2] ... [, xoutargN]\"",
        "\"dispfft\";\"Signal I/O:Printing and Display\";\"Displays the Fourier Transform of an audio or control signal.\";\"dispfft xsig, iprd, iwsiz [, iwtyp] [, idbout] [, iwtflg]\"",
        "\"display\";\"Signal I/O:Printing and Display\";\"Displays the audio or control signals as an amplitude vs. time graph.\";\"display xsig, iprd [, inprds] [, iwtflg]\"",
        "\"flashtxt\";\"Signal I/O:Printing and Display\";\"Allows text to be displayed from instruments like sliders\";\"flashtxt iwhich, String\"",
        "\"print\";\"Signal I/O:Printing and Display\";\"Displays the values init (i-rate) variables.\";\"print iarg [, iarg1] [, iarg2] [...]\"",
        "\"printf_i\";\"Signal I/O:Printing and Display\";\"printf-style formatted output\";\"printf_i Sfmt, itrig, [iarg1[, iarg2[, ... ]]]\"",
        "\"printf\";\"Signal I/O:Printing and Display\";\"printf-style formatted output\";\"printf Sfmt, ktrig, [xarg1[, xarg2[, ... ]]]\"",
        "\"printk\";\"Signal I/O:Printing and Display\";\"Prints one k-rate value at specified intervals.\";\"printk itime, kval [, ispace]\"",
        "\"printk2\";\"Signal I/O:Printing and Display\";\"Prints a new value every time a control variable changes.\";\"printk2 kvar [, inumspaces]\"",
        "\"printks\";\"Signal I/O:Printing and Display\";\"Prints at k-rate using a printf() style syntax.\";\"printks \"string\", itime [, kval1] [, kval2] [...]\"",
        "\"prints\";\"Signal I/O:Printing and Display\";\"Prints at init-time using a printf() style syntax.\";\"prints \"string\" [, kval1] [, kval2] [...]\"",
        "\"filebit\";\"Signal I/O:Soundfile Queries\";\"Returns the number of bits in each sample in a sound file.\";\"ir filebit ifilcod [, iallowraw]\"",
        "\"filelen\";\"Signal I/O:Soundfile Queries\";\"Returns the length of a sound file.\";\"ir filelen ifilcod, [iallowraw]\"",
        "\"filenchnls\";\"Signal I/O:Soundfile Queries\";\"Returns the number of channels in a sound file.\";\"ir filenchnls ifilcod [, iallowraw]\"",
        "\"filepeak\";\"Signal I/O:Soundfile Queries\";\"Returns the peak absolute value of a sound file.\";\"ir filepeak ifilcod [, ichnl]\"",
        "\"filesr\";\"Signal I/O:Soundfile Queries\";\"Returns the sample rate of a sound file.\";\"ir filesr ifilcod [, iallowraw]\"",
        "\"filevalid\";\"Signal I/O:Soundfile Queries\";\"Checks that a file can be used.\";\"ir filevalid ifilcod\"",
        "\"mp3len\";\"Signal I/O:Soundfile Queries\";\"Returns the length of an MP3 sound file.\";\"ir mp3len ifilcod\"",
        "\"balance\";\"Signal Modifiers:Amplitude Modifiers\";\"Adjust one audio signal according to the values of another.\";\"ares balance asig, acomp [, ihp] [, iskip]\"",
        "\"clip\";\"Signal Modifiers:Amplitude Modifiers\";\"Clips a signal to a predefined limit.\";\"ares clip asig, imeth, ilimit [, iarg]\"",
        "\"compress\";\"Signal Modifiers:Amplitude Modifiers\";\"Compress, limit, expand, duck or gate an audio signal.\";\"ar compress aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook\"",
        "\"dam\";\"Signal Modifiers:Amplitude Modifiers\";\"A dynamic compressor/expander.\";\"ares dam asig, kthreshold, icomp1, icomp2, irtime, iftime\"",
        "\"gain\";\"Signal Modifiers:Amplitude Modifiers\";\"Adjusts the amplitude audio signal according to a root-mean-square value.\";\"ares gain asig, krms [, ihp] [, iskip]\"",
        "\"convolve\";\"Signal Modifiers:Convolution and Morphing\";\"Convolves a signal and an impulse response.\";\"ar1 [, ar2] [, ar3] [, ar4] convolve ain, ifilcod [, ichannel]\"",
        "\"cross2\";\"Signal Modifiers:Convolution and Morphing\";\"Cross synthesis using FFT's.\";\"ares cross2 ain1, ain2, isize, ioverlap, iwin, kbias\"",
        "\"dconv\";\"Signal Modifiers:Convolution and Morphing\";\"A direct convolution opcode.\";\"ares dconv asig, isize, ifn\"",
        "\"ftconv\";\"Signal Modifiers:Convolution and Morphing\";\"Low latency multichannel convolution, using a function table as impulse response source.\";\"a1[, a2[, a3[, ... a8]]] ftconv ain, ift, iplen[, iskipsamples  [, iirlen[, iskipinit]]]\"",
        "\"ftmorf\";\"Signal Modifiers:Convolution and Morphing\";\"Morphs between multiple ftables as specified in a list.\";\"ftmorf kftndx, iftfn, iresfn\"",
        "\"pconvolve\";\"Signal Modifiers:Convolution and Morphing\";\"Convolution based on a uniformly partitioned overlap-save algorithm\";\"ar1 [, ar2] [, ar3] [, ar4] pconvolve ain, ifilcod [, ipartitionsize, ichannel]\"",
        "\"delay\";\"Signal Modifiers:Delay\";\"Delays an input signal by some time interval.\";\"ares delay asig, idlt [, iskip]\"",
        "\"delay1\";\"Signal Modifiers:Delay\";\"Delays an input signal by one sample.\";\"ares delay1 asig [, iskip]\"",
        "\"delayk \";\"Signal Modifiers:Delay\";\"Delays an input signal by some time interval.\";\"kr delayk ksig, idel[, imode]\"",
        "\"vdel_k \";\"Signal Modifiers:Delay\";\"Delays an input signal by some time interval.\";\"kr vdel_k ksig, kdel, imdel[, imode]\"",
        "\"delayr\";\"Signal Modifiers:Delay\";\"Reads from an automatically established digital delay line.\";\"ares delayr idlt [, iskip]\"",
        "\"delayw\";\"Signal Modifiers:Delay\";\"Writes the audio signal to a digital delay line.\";\"delayw asig\"",
        "\"deltap\";\"Signal Modifiers:Delay\";\"Taps a delay line at variable offset times.\";\"ares deltap kdlt\"",
        "\"deltap3\";\"Signal Modifiers:Delay\";\"Taps a delay line at variable offset times, uses cubic interpolation.\";\"ares deltap3 xdlt\"",
        "\"deltapi\";\"Signal Modifiers:Delay\";\"Taps a delay line at variable offset times, uses interpolation.\";\"ares deltapi xdlt\"",
        "\"deltapn\";\"Signal Modifiers:Delay\";\"Taps a delay line at variable offset times.\";\"ares deltapn xnumsamps\"",
        "\"deltapx\";\"Signal Modifiers:Delay\";\"Read from or write to a delay line with interpolation.\";\"aout deltapx adel, iwsize\"",
        "\"deltapxw\";\"Signal Modifiers:Delay\";\"Mixes the input signal to a delay line.\";\"deltapxw ain, adel, iwsize\"",
        "\"multitap\";\"Signal Modifiers:Delay\";\"Multitap delay line implementation.\";\"ares multitap asig [, itime1, igain1] [, itime2, igain2] [...]\"",
        "\"newopcodename\";\"Signal Modifiers:Delay\";\"Short description. Single line for opcode listing.\";\"outarg1, outarg2 newopcodename inarg1, inarg2\"",
        "\"vdelay\";\"Signal Modifiers:Delay\";\"An interpolating variable time delay.\";\"ares vdelay asig, adel, imaxdel [, iskip]\"",
        "\"vdelay3\";\"Signal Modifiers:Delay\";\"A variable time delay with cubic interpolation.\";\"ares vdelay3 asig, adel, imaxdel [, iskip]\"",
        "\"vdelayx\";\"Signal Modifiers:Delay\";\"A variable delay opcode with high quality interpolation.\";\"aout vdelayx ain, adl, imd, iws [, ist]\"",
        "\"vdelayxq\";\"Signal Modifiers:Delay\";\"A 4-channel variable delay opcode with high quality interpolation.\";\"aout1, aout2, aout3, aout4 vdelayxq ain1, ain2, ain3, ain4, adl, imd, iws [, ist]\"",
        "\"vdelayxs\";\"Signal Modifiers:Delay\";\"A stereo variable delay opcode with high quality interpolation.\";\"aout1, aout2 vdelayxs ain1, ain2, adl, imd, iws [, ist]\"",
        "\"vdelayxw\";\"Signal Modifiers:Delay\";\"Variable delay opcodes with high quality interpolation.\";\"aout vdelayxw ain, adl, imd, iws [, ist]\"",
        "\"vdelayxwq\";\"Signal Modifiers:Delay\";\"Variable delay opcodes with high quality interpolation.\";\"aout1, aout2, aout3, aout4 vdelayxwq ain1, ain2, ain3, ain4, adl,  imd, iws [, ist]\"",
        "\"vdelayxws\";\"Signal Modifiers:Delay\";\"Variable delay opcodes with high quality interpolation.\";\"aout1, aout2 vdelayxws ain1, ain2, adl, imd, iws [, ist]\"",
        "\"bformdec\";\"Signal Modifiers:Panning and Spatialization\";\"Deprecated. Decodes an ambisonic B format signal.\";\"ao1, ao2 bformdec isetup, aw, ax, ay, az [, ar, as, at, au, av  [, abk, al, am, an, ao, ap, aq]]\"",
        "\"bformdec1\";\"Signal Modifiers:Panning and Spatialization\";\"Decodes an ambisonic B format signal\";\"ao1, ao2 bformdec1 isetup, aw, ax, ay, az [, ar, as, at, au, av  [, abk, al, am, an, ao, ap, aq]]\"",
        "\"bformenc\";\"Signal Modifiers:Panning and Spatialization\";\"Deprecated. Codes a signal into the ambisonic B format.\";\"aw, ax, ay, az bformenc asig, kalpha, kbeta, kord0, kord1\"",
        "\"bformenc1\";\"Signal Modifiers:Panning and Spatialization\";\"Codes a signal into the ambisonic B format.\";\"aw, ax, ay, az bformenc1 asig, kalpha, kbeta\"",
        "\"hrtfearly\";\"Signal Modifiers:Panning and Spatialization\";\"Generates 3D binaural audio with high-fidelity early reflections in a parametric room using a Phase Truncation algorithm.\";\"aleft, aright, irt60low, irt60high, imfp hrtfearly asrc, ksrcx, ksrcy, ksrcz, klstnrx, klstnry, klstnrz,  ifilel, ifiler, idefroom [,ifade, isr, iorder, ithreed, kheadrot, iroomx, iroomy, iroomz, iwallhigh,  iwalllow, iwallgain1, iwallgain2, iwallgain3, ifloorhigh, ifloorlow, ifloorgain1, ifloorgain2,  ifloorgain3, iceilinghigh, iceilinglow, iceilinggain1, iceilinggain2, iceilinggain3]\"",
        "\"hrtfer\";\"Signal Modifiers:Panning and Spatialization\";\"Creates 3D audio for two speakers.\";\"aleft, aright hrtfer asig, kaz, kelev, HRTFcompact\"",
        "\"hrtfmove\";\"Signal Modifiers:Panning and Spatialization\";\"Generates dynamic 3d binaural audio for headphones using magnitude interpolation and phase truncation.\";\"aleft, aright hrtfmove asrc, kAz, kElev, ifilel, ifiler [, imode, ifade, isr]\"",
        "\"hrtfmove2\";\"Signal Modifiers:Panning and Spatialization\";\"Generates dynamic 3d binaural audio for headphones using a Woodworth based spherical head model with improved low frequency phase accuracy.\";\"aleft, aright hrtfmove2 asrc, kAz, kElev, ifilel, ifiler [,ioverlap, iradius, isr]\"",
        "\"hrtfstat\";\"Signal Modifiers:Panning and Spatialization\";\"Generates static 3d binaural audio for headphones using a Woodworth based spherical head model with improved low frequency phase accuracy.\";\"aleft, aright hrtfstat asrc, iAz, iElev, ifilel, ifiler [,iradius, isr]\"",
        "\"locsend\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes the audio signals of a previous\";\"a1, a2 locsend\"",
        "\"locsig\";\"Signal Modifiers:Panning and Spatialization\";\"Takes an input signal and distributes between 2 or 4 channels.\";\"a1, a2 locsig asig, kdegree, kdistance, kreverbsend\"",
        "\"pan\";\"Signal Modifiers:Panning and Spatialization\";\"Distribute an audio signal amongst four channels.\";\"a1, a2, a3, a4 pan asig, kx, ky, ifn [, imode] [, ioffset]\"",
        "\"pan2\";\"Signal Modifiers:Panning and Spatialization\";\"Distribute an audio signal across two channels.\";\"a1, a2 pan2 asig, xp [, imode]\"",
        "\"space\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an input signal among 4 channels using cartesian coordinates.\";\"a1, a2, a3, a4 space asig, ifn, ktime, kreverbsend, kx, ky\"",
        "\"spat3d\";\"Signal Modifiers:Panning and Spatialization\";\"Positions the input sound in a 3D space and allows moving the sound at k-rate.\";\"aW, aX, aY, aZ spat3d ain, kX, kY, kZ, idist, ift, imode, imdel, iovr [, istor]\"",
        "\"spat3di\";\"Signal Modifiers:Panning and Spatialization\";\"Positions the input sound in a 3D space with the sound source position set at i-time.\";\"aW, aX, aY, aZ spat3di ain, iX, iY, iZ, idist, ift, imode [, istor]\"",
        "\"spat3dt\";\"Signal Modifiers:Panning and Spatialization\";\"Can be used to render an impulse response for a 3D space at i-time.\";\"spat3dt ioutft, iX, iY, iZ, idist, ift, imode, irlen [, iftnocl]\"",
        "\"spdist\";\"Signal Modifiers:Panning and Spatialization\";\"Calculates distance values from xy coordinates.\";\"k1 spdist ifn, ktime, kx, ky\"",
        "\"spsend\";\"Signal Modifiers:Panning and Spatialization\";\"Generates output signals based on a previously defined\";\"a1, a2, a3, a4 spsend\"",
        "\"vbap16\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an audio signal among 16 channels.\";\"ar1, ..., ar16 vbap16 asig, kazim [, kelev] [, kspread]\"",
        "\"vbap16move\";\"Signal Modifiers:Panning and Spatialization\";\"Distribute an audio signal among 16 channels with moving virtual sources.\";\"ar1, ..., ar16 vbap16move asig, idur, ispread, ifldnum, ifld1  [, ifld2] [...]\"",
        "\"vbap4\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an audio signal among 4 channels.\";\"ar1, ar2, ar3, ar4 vbap4 asig, kazim [, kelev] [, kspread]\"",
        "\"vbap4move\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an audio signal among 4 channels with moving virtual sources.\";\"ar1, ar2, ar3, ar4 vbap4move asig, idur, ispread, ifldnum, ifld1  [, ifld2] [...]\"",
        "\"vbap8\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an audio signal among 8 channels.\";\"ar1, ..., ar8 vbap8 asig, kazim [, kelev] [, kspread]\"",
        "\"vbap8move\";\"Signal Modifiers:Panning and Spatialization\";\"Distributes an audio signal among 8 channels with moving virtual sources.\";\"ar1, ..., ar8 vbap8move asig, idur, ispread, ifldnum, ifld1  [, ifld2] [...]\"",
        "\"vbaplsinit\";\"Signal Modifiers:Panning and Spatialization\";\"Configures VBAP output according to loudspeaker parameters.\";\"vbaplsinit idim, ilsnum [, idir1] [, idir2] [...] [, idir32]\"",
        "\"vbapz\";\"Signal Modifiers:Panning and Spatialization\";\"Writes a multi-channel audio signal to a ZAK array.\";\"vbapz inumchnls, istartndx, asig, kazim [, kelev] [, kspread]\"",
        "\"vbapzmove\";\"Signal Modifiers:Panning and Spatialization\";\"Writes a multi-channel audio signal to a ZAK array with moving virtual sources.\";\"vbapzmove inumchnls, istartndx, asig, idur, ispread, ifldnum, ifld1,  ifld2, [...]\"",
        "\"alpass\";\"Signal Modifiers:Reverberation\";\"Reverberates an input signal with a flat frequency response.\";\"ares alpass asig, krvt, ilpt [, iskip] [, insmps]\"",
        "\"babo\";\"Signal Modifiers:Reverberation\";\"A physical model reverberator.\";\"a1, a2 babo asig, ksrcx, ksrcy, ksrcz, irx, iry, irz [, idiff] [, ifno]\"",
        "\"comb\";\"Signal Modifiers:Reverberation\";\"Reverberates an input signal with a\";\"ares comb asig, krvt, ilpt [, iskip] [, insmps]\"",
        "\"freeverb\";\"Signal Modifiers:Reverberation\";\"Opcode version of Jezar's Freeverb\";\"aoutL, aoutR freeverb ainL, ainR, kRoomSize, kHFDamp[, iSRate[, iSkip]]\"",
        "\"nestedap\";\"Signal Modifiers:Reverberation\";\"Three different nested all-pass filters.\";\"ares nestedap asig, imode, imaxdel, idel1, igain1 [, idel2] [, igain2]  [, idel3] [, igain3] [, istor]\"",
        "\"nreverb\";\"Signal Modifiers:Reverberation\";\"A reverberator consisting of 6 parallel comb-lowpass filters.\";\"ares nreverb asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs]  [, inumAlpas] [, ifnAlpas]\"",
        "\"reverb\";\"Signal Modifiers:Reverberation\";\"Reverberates an input signal with a\";\"ares reverb asig, krvt [, iskip]\"",
        "\"reverb2\";\"Signal Modifiers:Reverberation\";\"Same as the nreverb opcode.\";\"ares reverb2 asig, ktime, khdif [, iskip] [,inumCombs]  [, ifnCombs] [, inumAlpas] [, ifnAlpas]\"",
        "\"reverbsc\";\"Signal Modifiers:Reverberation\";\"8 delay line stereo FDN reverb, based on work by Sean Costello\";\"aoutL, aoutR reverbsc ainL, ainR, kfblvl, kfco[, israte[, ipitchm[, iskip]]]\"",
        "\"valpass\";\"Signal Modifiers:Reverberation\";\"Variably reverberates an input signal with a flat frequency response.\";\"ares valpass asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]\"",
        "\"vcomb\";\"Signal Modifiers:Reverberation\";\"Variably reverberates an input signal with a\";\"ares vcomb asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]\"",
        "\"denorm\";\"Signal Modifiers:Sample Level Operators\";\"Mixes low level noise to a list of a-rate signals\";\"denorm a1[, a2[, a3[, ... ]]]\"",
        "\"diff\";\"Signal Modifiers:Sample Level Operators\";\"Modify a signal by differentiation.\";\"ares diff asig [, iskip]\"",
        "\"downsamp\";\"Signal Modifiers:Sample Level Operators\";\"Modify a signal by down-sampling.\";\"kres downsamp asig [, iwlen]\"",
        "\"fold\";\"Signal Modifiers:Sample Level Operators\";\"Adds artificial foldover to an audio signal.\";\"ares fold asig, kincr\"",
        "\"integ\";\"Signal Modifiers:Sample Level Operators\";\"Modify a signal by integration.\";\"ares integ asig [, iskip]\"",
        "\"interp\";\"Signal Modifiers:Sample Level Operators\";\"Converts a control signal to an audio signal using linear interpolation.\";\"ares interp ksig [, iskip] [, imode]\"",
        "\"ntrpol\";\"Signal Modifiers:Sample Level Operators\";\"Calculates the weighted mean value of two input signals.\";\"ares ntrpol asig1, asig2, kpoint [, imin] [, imax]\"",
        "\"a\";\"Signal Modifiers:Sample Level Operators\";\"Converts a k-rate parameter to an a-rate value with interpolation.\";\"a(x) (control-rate args only)\"",
        "\"i\";\"Signal Modifiers:Sample Level Operators\";\"Returns an init-type equivalent of a k-rate argument, or directly returns an i-rate argument.\";\"i(x) (control-rate or init-rate arg)\"",
        "\"k\";\"Signal Modifiers:Sample Level Operators\";\"Converts a i-rate parameter to an k-rate value.\";\"k(x) (i-rate args only)\"",
        "\"samphold\";\"Signal Modifiers:Sample Level Operators\";\"Performs a sample-and-hold operation on its input.\";\"ares samphold asig, agate [, ival] [, ivstor]\"",
        "\"upsamp\";\"Signal Modifiers:Sample Level Operators\";\"Modify a signal by up-sampling.\";\"ares upsamp ksig\"",
        "\"vaget\";\"Signal Modifiers:Sample Level Operators\";\"Access values of the current buffer of an a-rate variable by indexing.\";\"kval vaget kndx, avar\"",
        "\"vaset\";\"Signal Modifiers:Sample Level Operators\";\"Write value of into the current buffer of an a-rate variable by index.\";\"vaset kval, kndx, avar\"",
        "\"limit\";\"Signal Modifiers:Signal Limiters\";\"Sets the lower and upper limits of the value it processes.\";\"ares limit asig, klow, khigh\"",
        "\"mirror\";\"Signal Modifiers:Signal Limiters\";\"Reflects the signal that exceeds the low and high thresholds.\";\"ares mirror asig, klow, khigh\"",
        "\"wrap\";\"Signal Modifiers:Signal Limiters\";\"Wraps-around the signal that exceeds the low and high thresholds.\";\"ares wrap asig, klow, khigh\"",
        "\"distort\";\"Signal Modifiers:Special Effects\";\"Distort an audio signal via waveshaping and optional clipping.\";\"ar distort asig, kdist, ifn[, ihp, istor]\"",
        "\"distort1\";\"Signal Modifiers:Special Effects\";\"Modified hyperbolic tangent distortion.\";\"ares distort1 asig, kpregain, kpostgain, kshape1, kshape2[, imode]\"",
        "\"flanger\";\"Signal Modifiers:Special Effects\";\"A user controlled flanger.\";\"ares flanger asig, adel, kfeedback [, imaxd]\"",
        "\"harmon\";\"Signal Modifiers:Special Effects\";\"Analyze an audio input and generate harmonizing voices in synchrony.\";\"ares harmon asig, kestfrq, kmaxvar, kgenfreq1, kgenfreq2, imode,  iminfrq, iprd\"",
        "\"harmon2\";\"Signal Modifiers:Special Effects\";\"Analyze an audio input and generate harmonizing voices in synchrony with formants preserved.\";\"ares harmon2 asig, koct, kfrq1, kfrq2, icpsmode, ilowest[, ipolarity]\"",
        "\"harmon3\";\"Signal Modifiers:Special Effects\";\"Analyze an audio input and generate harmonizing voices in synchrony with formants preserved.\";\"ares harmon3 asig, koct, kfrq1,  kfrq2, kfrq3, icpsmode, ilowest[, ipolarity]\"",
        "\"harmon4\";\"Signal Modifiers:Special Effects\";\"Analyze an audio input and generate harmonizing voices in synchrony with formants preserved.\";\"ares harmon4 asig, koct, kfrq1,  kfrq2, kfrq3, kfrq4, icpsmode, ilowest[, ipolarity]\"",
        "\"phaser1\";\"Signal Modifiers:Special Effects\";\"First-order allpass filters arranged in a series.\";\"ares phaser1 asig, kfreq, kord, kfeedback [, iskip]\"",
        "\"phaser2\";\"Signal Modifiers:Special Effects\";\"Second-order allpass filters arranged in a series.\";\"ares phaser2 asig, kfreq, kq, kord, kmode, ksep, kfeedback\"",
        "\"atone\";\"Signal Modifiers:Standard Filters\";\"A hi-pass filter whose transfer functions are the complements of the\";\"ares atone asig, khp [, iskip]\"",
        "\"atonex\";\"Signal Modifiers:Standard Filters\";\"Emulates a stack of filters using the atone opcode.\";\"ares atonex asig, khp [, inumlayer] [, iskip]\"",
        "\"biquad\";\"Signal Modifiers:Standard Filters\";\"A sweepable general purpose biquadratic digital filter.\";\"ares biquad asig, kb0, kb1, kb2, ka0, ka1, ka2 [, iskip]\"",
        "\"biquada\";\"Signal Modifiers:Standard Filters\";\"A sweepable general purpose biquadratic digital filter with a-rate parameters.\";\"ares biquada asig, ab0, ab1, ab2, aa0, aa1, aa2 [, iskip]\"",
        "\"butbp\";\"Signal Modifiers:Standard Filters\";\"Same as the butterbp opcode.\";\"ares butbp asig, kfreq, kband [, iskip]\"",
        "\"butbr\";\"Signal Modifiers:Standard Filters\";\"Same as the butterbr opcode.\";\"ares butbr asig, kfreq, kband [, iskip]\"",
        "\"buthp\";\"Signal Modifiers:Standard Filters\";\"Same as the butterhp opcode.\";\"ares buthp asig, kfreq [, iskip]\"",
        "\"butlp\";\"Signal Modifiers:Standard Filters\";\"Same as the butterlp opcode.\";\"ares butlp asig, kfreq [, iskip]\"",
        "\"butterbp\";\"Signal Modifiers:Standard Filters\";\"A band-pass Butterworth filter.\";\"ares butterbp asig, kfreq, kband [, iskip]\"",
        "\"butterbr\";\"Signal Modifiers:Standard Filters\";\"A band-reject Butterworth filter.\";\"ares butterbr asig, kfreq, kband [, iskip]\"",
        "\"butterhp\";\"Signal Modifiers:Standard Filters\";\"A high-pass Butterworth filter.\";\"ares butterhp asig, kfreq [, iskip]\"",
        "\"butterlp\";\"Signal Modifiers:Standard Filters\";\"A low-pass Butterworth filter.\";\"ares butterlp asig, kfreq [, iskip]\"",
        "\"clfilt\";\"Signal Modifiers:Standard Filters\";\"Implements low-pass and high-pass filters of different styles.\";\"ares clfilt asig, kfreq, itype, inpol [, ikind] [, ipbr] [, isba] [, iskip]\"",
        "\"doppler\";\"Signal Modifiers:Standard Filters\";\"A fast and robust method for approximating sound propagation, achieving convincing Doppler shifts without having to solve equations.\";\"ashifted doppler asource, ksourceposition, kmicposition [, isoundspeed, ifiltercutoff]\"",
        "\"mode\";\"Signal Modifiers:Standard Filters\";\"A filter that simulates a mass-spring-damper system\";\"aout mode ain, kfreq, kQ [, iskip]\"",
        "\"tone\";\"Signal Modifiers:Standard Filters\";\"A first-order recursive low-pass filter with variable frequency response.\";\"ares tone asig, khp [, iskip]\"",
        "\"tonex\";\"Signal Modifiers:Standard Filters\";\"Emulates a stack of filters using the tone opcode.\";\"ares tonex asig, khp [, inumlayer] [, iskip]\"",
        "\"areson\";\"Signal Modifiers:Standard Filters:Resonant\";\"A notch filter whose transfer functions are the complements of the reson opcode.\";\"ares areson asig, kcf, kbw [, iscl] [, iskip]\"",
        "\"bqrez\";\"Signal Modifiers:Standard Filters:Resonant\";\"A second-order multi-mode filter.\";\"ares bqrez asig, xfco, xres [, imode] [, iskip]\"",
        "\"lowpass2\";\"Signal Modifiers:Standard Filters:Resonant\";\"A resonant lowpass filter.\";\"ares lowpass2 asig, kcf, kq [, iskip]\"",
        "\"lowres\";\"Signal Modifiers:Standard Filters:Resonant\";\"Another resonant lowpass filter.\";\"ares lowres asig, kcutoff, kresonance [, iskip]\"",
        "\"lowresx\";\"Signal Modifiers:Standard Filters:Resonant\";\"Simulates layers of serially connected resonant lowpass filters.\";\"ares lowresx asig, kcutoff, kresonance [, inumlayer] [, iskip]\"",
        "\"lpf18\";\"Signal Modifiers:Standard Filters:Resonant\";\"A 3-pole sweepable resonant lowpass filter.\";\"ares lpf18 asig, kfco, kres, kdist [, iskip]\"",
        "\"moogladder\";\"Signal Modifiers:Standard Filters:Resonant\";\"Moog ladder lowpass filter.\";\"asig moogladder ain, kcf, kres[, istor]\"",
        "\"moogvcf\";\"Signal Modifiers:Standard Filters:Resonant\";\"A digital emulation of the Moog diode ladder filter configuration.\";\"ares moogvcf asig, xfco, xres [,iscale, iskip]\"",
        "\"moogvcf2\";\"Signal Modifiers:Standard Filters:Resonant\";\"A digital emulation of the Moog diode ladder filter configuration.\";\"ares moogvcf2 asig, xfco, xres [,iscale, iskip]\"",
        "\"reson\";\"Signal Modifiers:Standard Filters:Resonant\";\"A second-order resonant filter.\";\"ares reson asig, kcf, kbw [, iscl] [, iskip]\"",
        "\"resonr\";\"Signal Modifiers:Standard Filters:Resonant\";\"A bandpass filter with variable frequency response.\";\"ares resonr asig, kcf, kbw [, iscl] [, iskip]\"",
        "\"resonx\";\"Signal Modifiers:Standard Filters:Resonant\";\"Emulates a stack of filters using the reson opcode.\";\"ares resonx asig, kcf, kbw [, inumlayer] [, iscl] [, iskip]\"",
        "\"resony\";\"Signal Modifiers:Standard Filters:Resonant\";\"A bank of second-order bandpass filters, connected in parallel.\";\"ares resony asig, kbf, kbw, inum, ksep [, isepmode] [, iscl] [, iskip]\"",
        "\"resonz\";\"Signal Modifiers:Standard Filters:Resonant\";\"A bandpass filter with variable frequency response.\";\"ares resonz asig, kcf, kbw [, iscl] [, iskip]\"",
        "\"rezzy\";\"Signal Modifiers:Standard Filters:Resonant\";\"A resonant low-pass filter.\";\"ares rezzy asig, xfco, xres [, imode, iskip]\"",
        "\"statevar\";\"Signal Modifiers:Standard Filters:Resonant\";\"State-variable filter.\";\"ahp,alp,abp,abr statevar ain, kcf, kq [, iosamps, istor]\"",
        "\"svfilter\";\"Signal Modifiers:Standard Filters:Resonant\";\"A resonant second order filter, with simultaneous lowpass, highpass and bandpass outputs.\";\"alow, ahigh, aband svfilter asig, kcf, kq [, iscl]\"",
        "\"tbvcf\";\"Signal Modifiers:Standard Filters:Resonant\";\"Models some of the filter characteristics of a Roland TB303 voltage-controlled filter.\";\"ares tbvcf asig, xfco, xres, kdist, kasym [, iskip]\"",
        "\"vlowres\";\"Signal Modifiers:Standard Filters:Resonant\";\"A bank of filters in which the cutoff frequency can be separated under user control.\";\"ares vlowres asig, kfco, kres, iord, ksep\"",
        "\"aresonk\";\"Signal Modifiers:Standard Filters:Control\";\"A notch filter whose transfer functions are the complements of the reson opcode.\";\"kres aresonk ksig, kcf, kbw [, iscl] [, iskip]\"",
        "\"atonek\";\"Signal Modifiers:Standard Filters:Control\";\"A hi-pass filter whose transfer functions are the complements of the\";\"kres atonek ksig, khp [, iskip]\"",
        "\"lineto\";\"Signal Modifiers:Standard Filters:Control\";\"Generate glissandos starting from a control signal.\";\"kres lineto ksig, ktime\"",
        "\"port\";\"Signal Modifiers:Standard Filters:Control\";\"Applies portamento to a step-valued control signal.\";\"kres port ksig, ihtim [, isig]\"",
        "\"portk\";\"Signal Modifiers:Standard Filters:Control\";\"Applies portamento to a step-valued control signal.\";\"kres portk ksig, khtim [, isig]\"",
        "\"resonk\";\"Signal Modifiers:Standard Filters:Control\";\"A second-order resonant filter.\";\"kres resonk ksig, kcf, kbw [, iscl] [, iskip]\"",
        "\"resonxk\";\"Signal Modifiers:Standard Filters:Control\";\"Control signal resonant filter stack.\";\"kres resonxk ksig, kcf, kbw[, inumlayer, iscl, istor]\"",
        "\"tlineto\";\"Signal Modifiers:Standard Filters:Control\";\"Generate glissandos starting from a control signal.\";\"kres tlineto ksig, ktime, ktrig\"",
        "\"tonek\";\"Signal Modifiers:Standard Filters:Control\";\"A first-order recursive low-pass filter with variable frequency response.\";\"kres tonek ksig, khp [, iskip]\"",
        "\"dcblock\";\"Signal Modifiers:Specialized Filters\";\"A DC blocking filter.\";\"ares dcblock ain [, igain]\"",
        "\"dcblock2\";\"Signal Modifiers:Specialized Filters\";\"A DC blocking filter.\";\"ares dcblock2 ain [, iorder] [, iskip]\"",
        "\"eqfil\";\"Signal Modifiers:Specialized Filters\";\"Equalizer filter\";\"asig eqfil ain, kcf, kbw, kgain[, istor]\"",
        "\"filter2\";\"Signal Modifiers:Specialized Filters\";\"Performs filtering using a transposed form-II digital filter lattice with no time-varying control.\";\"ares filter2 asig, iM, iN, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN\"",
        "\"fofilter\";\"Signal Modifiers:Specialized Filters\";\"Formant filter.\";\"asig fofilter ain, kcf, kris, kdec[, istor]\"",
        "\"hilbert\";\"Signal Modifiers:Specialized Filters\";\"A Hilbert transformer.\";\"ar1, ar2 hilbert asig\"",
        "\"nlfilt\";\"Signal Modifiers:Specialized Filters\";\"A filter with a non-linear effect.\";\"ares nlfilt ain, ka, kb, kd, kC, kL\"",
        "\"pareq\";\"Signal Modifiers:Specialized Filters\";\"Implementation of Zoelzer's parametric equalizer filters.\";\"ares pareq asig, kc, kv, kq [, imode] [, iskip]\"",
        "\"rbjeq\";\"Signal Modifiers:Specialized Filters\";\"Parametric equalizer and filter opcode with 7 filter types, based on algorithm by Robert Bristow-Johnson.\";\"ar rbjeq asig, kfco, klvl, kQ, kS[, imode]\"",
        "\"zfilter2\";\"Signal Modifiers:Specialized Filters\";\"Performs filtering using a transposed form-II digital filter lattice with radial pole-shearing and angular pole-warping.\";\"ares zfilter2 asig, kdamp, kfreq, iM, iN, ib0, ib1, ..., ibM,  ia1,ia2, ..., iaN\"",
        "\"wguide1\";\"Signal Modifiers:Waveguides\";\"A simple waveguide model consisting of one delay-line and one first-order lowpass filter.\";\"ares wguide1 asig, xfreq, kcutoff, kfeedback\"",
        "\"wguide2\";\"Signal Modifiers:Waveguides\";\"A model of beaten plate consisting of two parallel delay-lines and two first-order lowpass filters.\";\"ares wguide2 asig, xfreq1, xfreq2, kcutoff1, kcutoff2,  kfeedback1, kfeedback2\"",
        "\"chebyshevpoly\";\"Signal Modifiers:Waveshaping\";\"Efficiently evaluates the sum of Chebyshev polynomials of arbitrary order.\";\"aout chebyshevpoly ain, k0 [, k1 [, k2 [...]]]\"",
        "\"pdclip\";\"Signal Modifiers:Waveshaping\";\"Performs linear clipping on an audio signal or a phasor.\";\"aout pdclip ain, kWidth, kCenter [, ibipolar [, ifullscale]]\"",
        "\"pdhalf\";\"Signal Modifiers:Waveshaping\";\"Distorts a phasor for reading the two halves of a table at different rates.\";\"aout pdhalf ain, kShapeAmount [, ibipolar [, ifullscale]]\"",
        "\"pdhalfy\";\"Signal Modifiers:Waveshaping\";\"Distorts a phasor for reading two unequal portions of a table in equal periods.\";\"aout pdhalfy ain, kShapeAmount [, ibipolar [, ifullscale]]\"",
        "\"powershape\";\"Signal Modifiers:Waveshaping\";\"Waveshapes a signal by raising it to a variable exponent.\";\"aout powershape ain, kShapeAmount [, ifullscale]\"",
        "\"max\";\"Signal Modifiers:Comparators and Accumulators\";\"Produces a signal that is the maximum of any number of input signals.\";\"amax max ain1, ain2 [, ain3] [, ain4] [...]\"",
        "\"max_k\";\"Signal Modifiers:Comparators and Accumulators\";\"Local maximum (or minimum) value of an incoming asig signal\";\"knumkout max_k asig, ktrig, itype\"",
        "\"maxabs\";\"Signal Modifiers:Comparators and Accumulators\";\"Produces a signal that is the maximum of the absolute values of any number of input signals.\";\"amax maxabs ain1, ain2 [, ain3] [, ain4] [...]\"",
        "\"maxabsaccum\";\"Signal Modifiers:Comparators and Accumulators\";\"Accumulates the maximum of the absolute values of audio signals.\";\"maxabsaccum aAccumulator, aInput\"",
        "\"maxaccum\";\"Signal Modifiers:Comparators and Accumulators\";\"Accumulates the maximum value of audio signals.\";\"maxaccum aAccumulator, aInput\"",
        "\"min\";\"Signal Modifiers:Comparators and Accumulators\";\"Produces a signal that is the minimum of any number of input signals.\";\"amin min ain1, ain2 [, ain3] [, ain4] [...]\"",
        "\"minabs\";\"Signal Modifiers:Comparators and Accumulators\";\"Produces a signal that is the minimum of the absolute values of any number of input signals.\";\"amin minabs ain1, ain2 [, ain3] [, ain4] [...]\"",
        "\"minabsaccum\";\"Signal Modifiers:Comparators and Accumulators\";\"Accumulates the minimum of the absolute values of audio signals.\";\"minabsaccum aAccumulator, aInput\"",
        "\"minaccum\";\"Signal Modifiers:Comparators and Accumulators\";\"Accumulates the minimum value of audio signals.\";\"minaccum aAccumulator, aInput\"",
        "\"clockoff\";\"Instrument Control:Clock Control\";\"Stops one of a number of internal clocks.\";\"clockoff inum\"",
        "\"clockon\";\"Instrument Control:Clock Control\";\"Starts one of a number of internal clocks.\";\"clockon inum\"",
        "\"ihold\";\"Instrument Control:Duration Control\";\"Creates a held note.\";\"ihold\"",
        "\"turnoff\";\"Instrument Control:Duration Control\";\"Enables an instrument to turn itself off.\";\"turnoff\"",
        "\"turnoff2\";\"Instrument Control:Duration Control\";\"Turn off instance(s) of other instruments at performance time.\";\"turnoff2 kinsno, kmode, krelease\"",
        "\"turnon\";\"Instrument Control:Duration Control\";\"Activate an instrument for an indefinite time.\";\"turnon insnum [, itime]\"",
        "\"event\";\"Instrument Control:Invocation\";\"Generates a score event from an instrument.\";\"event \"scorechar\", kinsnum, kdelay, kdur, [, kp4] [, kp5] [, ...]\"",
        "\"event_i\";\"Instrument Control:Invocation\";\"Generates a score event from an instrument.\";\"event_i \"scorechar\", iinsnum, idelay, idur, [, ip4] [, ip5] [, ...]\"",
        "\"mute\";\"Instrument Control:Invocation\";\"Mutes/unmutes new instances of a given instrument.\";\"mute insnum [, iswitch]\"",
        "\"remove\";\"Instrument Control:Invocation\";\"Removes the definition of an instrument.\";\"remove insnum\"",
        "\"schedkwhen\";\"Instrument Control:Invocation\";\"Adds a new score event generated by a k-rate trigger.\";\"schedkwhen ktrigger, kmintim, kmaxnum, kinsnum, kwhen, kdur  [, ip4] [, ip5] [...]\"",
        "\"schedkwhennamed\";\"Instrument Control:Invocation\";\"Similar to schedkwhen but uses a named instrument at init-time.\";\"schedkwhennamed ktrigger, kmintim, kmaxnum, \"name\", kwhen, kdur  [, ip4] [, ip5] [...]\"",
        "\"schedule\";\"Instrument Control:Invocation\";\"Adds a new score event.\";\"schedule insnum, iwhen, idur [, ip4] [, ip5] [...]\"",
        "\"schedwhen\";\"Instrument Control:Invocation\";\"Adds a new score event.\";\"schedwhen ktrigger, kinsnum, kwhen, kdur [, ip4] [, ip5] [...]\"",
        "\"scoreline\";\"Instrument Control:Invocation\";\"Issues one or more score line events from an instrument.\";\"scoreline Sin, ktrig\"",
        "\"scoreline_i\";\"Instrument Control:Invocation\";\"Issues one or more score line events from an instrument at i-time.\";\"scoreline_i Sin\"",
        "\"cggoto\";\"Instrument Control:Program Flow Control\";\"Conditionally transfer control on every pass.\";\"cggoto condition, label\"",
        "\"cigoto\";\"Instrument Control:Program Flow Control\";\"Conditionally transfer control during the i-time pass.\";\"cigoto condition, label\"",
        "\"ckgoto\";\"Instrument Control:Program Flow Control\";\"Conditionally transfer control during the p-time passes.\";\"ckgoto condition, label\"",
        "\"cngoto\";\"Instrument Control:Program Flow Control\";\"Transfers control on every pass when a condition is not true.\";\"cngoto condition, label\"",
        "\"else\";\"Instrument Control:Program Flow Control\";\"Executes a block of code when an \"if...then\" condition is false.\";\"else\"",
        "\"elseif\";\"Instrument Control:Program Flow Control\";\"Defines another \"if...then\" condition when a \"if...then\" condition is false.\";\"elseif xa R xb then\"",
        "\"endif\";\"Instrument Control:Program Flow Control\";\"Closes a block of code that begins with an \"if...then\" statement.\";\"endif\"",
        "\"goto\";\"Instrument Control:Program Flow Control\";\"Transfer control on every pass.\";\"goto label\"",
        "\"if\";\"Instrument Control:Program Flow Control\";\"Branches conditionally at initialization or during performance time.\";\"if ia R ib igoto label\"",
        "\"igoto\";\"Instrument Control:Program Flow Control\";\"Transfer control during the i-time pass.\";\"igoto label\"",
        "\"kgoto\";\"Instrument Control:Program Flow Control\";\"Transfer control during the p-time passes.\";\"kgoto label\"",
        "\"loop_ge\";\"Instrument Control:Program Flow Control\";\"Looping constructions.\";\"loop_ge indx, idecr, imin, label\"",
        "\"loop_gt\";\"Instrument Control:Program Flow Control\";\"Looping constructions.\";\"loop_gt indx, idecr, imin, label\"",
        "\"loop_le\";\"Instrument Control:Program Flow Control\";\"Looping constructions.\";\"loop_le indx, incr, imax, label\"",
        "\"loop_lt\";\"Instrument Control:Program Flow Control\";\"Looping constructions.\";\"loop_lt indx, incr, imax, label\"",
        "\"tigoto\";\"Instrument Control:Program Flow Control\";\"Transfer control at i-time when a new note is being tied onto a previously held note\";\"tigoto label\"",
        "\"timout\";\"Instrument Control:Program Flow Control\";\"Conditional branch during p-time depending on elapsed note time.\";\"timout istrt, idur, label\"",
        "\"until\";\"Instrument Control:Program Flow Control\";\"A syntactic looping construction.\";\"until condition do ... od\"",
        "\"active\";\"Instrument Control:Realtime Performance Control\";\"Returns the number of active instances of an instrument.\";\"ir active insnum [,iopt]\"",
        "\"cpuprc\";\"Instrument Control:Realtime Performance Control\";\"Control allocation of cpu resources on a per-instrument basis, to optimize realtime output.\";\"cpuprc insnum, ipercent\"",
        "\"exitnow\";\"Instrument Control:Realtime Performance Control\";\"Exit Csound as fast as possible, with no cleaning up.\";\"exitnow\"",
        "\"jacktransport\";\"Instrument Control:Realtime Performance Control\";\"Start/stop jack_transport and can optionally relocate the playback head.\";\"jacktransport icommand [, ilocation]\"",
        "\"maxalloc\";\"Instrument Control:Realtime Performance Control\";\"Limits the number of allocations of an instrument.\";\"maxalloc insnum, icount\"",
        "\"prealloc\";\"Instrument Control:Realtime Performance Control\";\"Creates space for instruments but does not run them.\";\"prealloc insnum, icount\"",
        "\"init\";\"Instrument Control:Initialization and Reinitialization\";\"Puts the value of the i-time expression into a k-, a-rate or t- variable.\";\"ares init iarg\"",
        "\"nstrnum\";\"Instrument Control:Initialization and Reinitialization\";\"Returns the number of a named instrument.\";\"insno nstrnum \"name\"\"",
        "\"p\";\"Instrument Control:Initialization and Reinitialization\";\"Show the value in a given p-field.\";\"p(x)\"",
        "\"passign\";\"Instrument Control:Initialization and Reinitialization\";\"Assigns a range of p-fields to ivariables.\";\"ivar1, ... passign [istart]\"",
        "\"pset\";\"Instrument Control:Initialization and Reinitialization\";\"Defines and initializes numeric arrays at orchestra load time.\";\"pset icon1 [, icon2] [...]\"",
        "\"reinit\";\"Instrument Control:Initialization and Reinitialization\";\"Suspends a performance while a special initialization pass is executed.\";\"reinit label\"",
        "\"rigoto\";\"Instrument Control:Initialization and Reinitialization\";\"Transfers control during a reinit pass.\";\"rigoto label\"",
        "\"rireturn\";\"Instrument Control:Initialization and Reinitialization\";\"Terminates a reinit pass.\";\"rireturn\"",
        "\"tival\";\"Instrument Control:Initialization and Reinitialization\";\"Puts the value of the instrument's internal\";\"ir tival\"",
        "\"button\";\"Instrument Control:Sensing and Control\";\"Sense on-screen controls.\";\"kres button knum\"",
        "\"changed\";\"Instrument Control:Sensing and Control\";\"k-rate signal change detector.\";\"ktrig changed kvar1 [, kvar2,..., kvarN]\"",
        "\"checkbox\";\"Instrument Control:Sensing and Control\";\"Sense on-screen controls.\";\"kres checkbox knum\"",
        "\"control\";\"Instrument Control:Sensing and Control\";\"Configurable slider controls for realtime user input.\";\"kres control knum\"",
        "\"follow\";\"Instrument Control:Sensing and Control\";\"Envelope follower unit generator.\";\"ares follow asig, idt\"",
        "\"follow2\";\"Instrument Control:Sensing and Control\";\"Another controllable envelope extractor.\";\"ares follow2 asig, katt, krel\"",
        "\"getcfg\";\"Instrument Control:Sensing and Control\";\"Return Csound settings.\";\"Svalue getcfg iopt\"",
        "\"metro\";\"Instrument Control:Sensing and Control\";\"Trigger Metronome\";\"ktrig metro kfreq [, initphase]\"",
        "\"miditempo\";\"Instrument Control:Sensing and Control\";\"Returns the current tempo at k-rate, of either the MIDI file (if available) or the score\";\"ksig miditempo\"",
        "\"p5gconnect\";\"Instrument Control:Sensing and Control\";\"Reads data from a P5 Glove controller.\";\"p5gconnect\"",
        "\"p5gdata\";\"Instrument Control:Sensing and Control\";\"Reads data fields from an external P5 Glove.\";\"kres p5gdata kcontrol\"",
        "\"pcount\";\"Instrument Control:Sensing and Control\";\"Returns the number of pfields belonging to a note event.\";\"icount pcount\"",
        "\"peak\";\"Instrument Control:Sensing and Control\";\"Maintains the output equal to the highest absolute value received.\";\"kres peak asig\"",
        "\"pindex\";\"Instrument Control:Sensing and Control\";\"Returns the value of a specified pfield.\";\"ivalue pindex ipfieldIndex\"",
        "\"pitch\";\"Instrument Control:Sensing and Control\";\"Tracks the pitch of a signal.\";\"koct, kamp pitch asig, iupdte, ilo, ihi, idbthresh [, ifrqs] [, iconf]  [, istrt] [, iocts] [, iq] [, inptls] [, irolloff] [, iskip]\"",
        "\"pitchamdf\";\"Instrument Control:Sensing and Control\";\"Follows the pitch of a signal based on the AMDF method.\";\"kcps, krms pitchamdf asig, imincps, imaxcps [, icps] [, imedi]  [, idowns] [, iexcps] [, irmsmedi]\"",
        "\"ptrack\";\"Instrument Control:Sensing and Control\";\"Tracks the pitch of a signal.\";\"kcps, kamp ptrack asig, ihopsize[,ipeaks]\"",
        "\"rewindscore\";\"Instrument Control:Sensing and Control\";\"Rewinds the playback position of the current score performance.\";\"rewindscore\"",
        "\"rms\";\"Instrument Control:Sensing and Control\";\"Determines the root-mean-square amplitude of an audio signal.\";\"kres rms asig [, ihp] [, iskip]\"",
        "\"sensekey\";\"Instrument Control:Sensing and Control\";\"Returns the ASCII code of a key that has been pressed.\";\"kres[, kkeydown] sensekey\"",
        "\"sense\";\"Instrument Control:Sensing and Control\";\"(same as sensekey) Returns the ASCII code of a key that has been pressed.\";\"kres[, kkeydown] sensekey\"",
        "\"seqtime\";\"Instrument Control:Sensing and Control\";\"Generates a trigger signal according to the values stored in a table.\";\"ktrig_out seqtime ktime_unit, kstart, kloop, kinitndx, kfn_times\"",
        "\"seqtime2\";\"Instrument Control:Sensing and Control\";\"Generates a trigger signal according to the values stored in a table.\";\"ktrig_out seqtime2 ktrig_in, ktime_unit, kstart, kloop, kinitndx, kfn_times\"",
        "\"setctrl\";\"Instrument Control:Sensing and Control\";\"Configurable slider controls for realtime user input.\";\"setctrl inum, ival, itype\"",
        "\"setscorepos  ipos\";\"Instrument Control:Sensing and Control\";\"Sets the playback position of the current score performance to a given position.\";\"setscorepos ipos\"",
        "\"splitrig\";\"Instrument Control:Sensing and Control\";\"Split a trigger signal\";\"splitrig ktrig, kndx, imaxtics, ifn, kout1 [,kout2,...,koutN]\"",
        "\"tempest\";\"Instrument Control:Sensing and Control\";\"Estimate the tempo of beat patterns in a control signal.\";\"ktemp tempest kin, iprd, imindur, imemdur, ihp, ithresh, ihtim, ixfdbak,  istartempo, ifn [, idisprd] [, itweek]\"",
        "\"tempo\";\"Instrument Control:Sensing and Control\";\"Apply tempo control to an uninterpreted score.\";\"tempo ktempo, istartempo\"",
        "\"tempoval\";\"Instrument Control:Sensing and Control\";\"Reads the current value of the tempo.\";\"kres tempoval\"",
        "\"timedseq\";\"Instrument Control:Sensing and Control\";\"Time Variant Sequencer\";\"ktrig timedseq ktimpnt, ifn, kp1 [,kp2, kp3, ...,kpN]\"",
        "\"trigger\";\"Instrument Control:Sensing and Control\";\"Informs when a krate signal crosses a threshold.\";\"kout trigger ksig, kthreshold, kmode\"",
        "\"trigseq\";\"Instrument Control:Sensing and Control\";\"Accepts a trigger signal as input and outputs a group of values.\";\"trigseq ktrig_in, kstart, kloop, kinitndx, kfn_values, kout1 [, kout2] [...]\"",
        "\"wiiconnect\";\"Instrument Control:Sensing and Control\";\"Reads data from a number of external Nintendo Wiimote controllers.\";\"ires wiiconnect [itimeout, imaxnum]\"",
        "\"wiidata\";\"Instrument Control:Sensing and Control\";\"Reads data fields from a number of external Nintendo Wiimote controllers.\";\"kres wiidata kcontrol[, knum]\"",
        "\"wiirange\";\"Instrument Control:Sensing and Control\";\"Sets scaling and range limits for certain Wiimote fields.\";\"wiirange icontrol, iminimum, imaximum[, inum]\"",
        "\"wiisend\";\"Instrument Control:Sensing and Control\";\"Sends data to one of a number of external Nintendo Wiimote controllers.\";\"kres wiisend kcontrol, kvalue[, knum]\"",
        "\"xyin\";\"Instrument Control:Sensing and Control\";\"Sense the cursor position in an output window\";\"kx, ky xyin iprd, ixmin, ixmax, iymin, iymax [, ixinit] [, iyinit]\"",
        "\"pop\";\"Instrument Control:Stacks\";\"Pops values from the global stack.\";\"xval1, [xval2, ... , xval31] pop\"",
        "\"pop_f\";\"Instrument Control:Stacks\";\"Pops an f-sig frame from the global stack.\";\"fsig pop_f\"",
        "\"push\";\"Instrument Control:Stacks\";\"Pushes a value into the global stack.\";\"push xval1, [xval2, ... , xval31]\"",
        "\"push_f\";\"Instrument Control:Stacks\";\"Pushes an f-sig frame into the global stack.\";\"push_f fsig\"",
        "\"stack\";\"Instrument Control:Stacks\";\"Initializes the stack.\";\"stack iStackSize\"",
        "\"subinstr\";\"Instrument Control:Subinstrument Control\";\"Creates and runs a numbered instrument instance.\";\"a1, [...] [, a8] subinstr instrnum [, p4] [, p5] [...]\"",
        "\"subinstrinit\";\"Instrument Control:Subinstrument Control\";\"Creates and runs a numbered instrument instance at init-time.\";\"subinstrinit instrnum [, p4] [, p5] [...]\"",
        "\"date\";\"Instrument Control:Time Reading\";\"Returns the number seconds since a base date.\";\"ir date\"",
        "\"dates\";\"Instrument Control:Time Reading\";\"Returns as a string the date and time specified.\";\"Sir dates [ itime]\"",
        "\"readclock\";\"Instrument Control:Time Reading\";\"Reads the value of an internal clock.\";\"ir readclock inum\"",
        "\"rtclock\";\"Instrument Control:Time Reading\";\"Read the real time clock from the operating system.\";\"ires rtclock\"",
        "\"timeinstk\";\"Instrument Control:Time Reading\";\"Read absolute time in k-rate cycles.\";\"kres timeinstk\"",
        "\"timeinsts\";\"Instrument Control:Time Reading\";\"Read absolute time in seconds.\";\"kres timeinsts\"",
        "\"timek\";\"Instrument Control:Time Reading\";\"Read absolute time in k-rate cycles.\";\"ires timek\"",
        "\"times\";\"Instrument Control:Time Reading\";\"Read absolute time in seconds.\";\"ires times\"",
        "\"JackoAudioIn \";\"Jacko Opcodes\";\"Receives an audio signal from a Jack port.\";\"asignal JackoAudioIn ScsoundPortName\"",
        "\"JackoAudioInConnect \";\"Jacko Opcodes\";\"Creates an audio connection from a Jack port to Csound.\";\"JackoAudioInConnect SexternalPortName, ScsoundPortName\"",
        "\"JackoAudioOut \";\"Jacko Opcodes\";\"Sends an audio signal to a Jack port.\";\"JackoAudioOut ScsoundPortName, asignal\"",
        "\"JackoAudioOutConnect \";\"Jacko Opcodes\";\"Creates an audio connection from Csound to a Jack port.\";\"JackoAudioOutConnect ScsoundPortName, SexternalPortName\"",
        "\"JackoFreewheel \";\"Jacko Opcodes\";\"Turns Jack's freewheeling mode on or off.\";\"JackoFreewheel [ienabled]\"",
        "\"JackoInfo \";\"Jacko Opcodes\";\"Prints information about the Jack system.\";\"JackoInfo\"",
        "\"JackoInit \";\"Jacko Opcodes\";\"Initializes Csound as a Jack client.\";\"JackoInit SclientName, ServerName\"",
        "\"JackoMidiInConnect \";\"Jacko Opcodes\";\"Creates a MIDI connection from a Jack port to Csound.\";\"JackoMidiInConnect SexternalPortName, ScsoundPortName\"",
        "\"JackoMidiOut \";\"Jacko Opcodes\";\"Sends a MIDI channel message to a Jack port.\";\"JackoMidiOut ScsoundPortName, kstatus, kchannel, kdata1[, kdata2]\"",
        "\"JackoMidiOutConnect \";\"Jacko Opcodes\";\"Creates a MIDI connection from Csound to a Jack port.\";\"JackoMidiOutConnect ScsoundPortName, SexternalPortName\"",
        "\"JackoNoteOut \";\"Jacko Opcodes\";\"Sends a MIDI channel message to a Jack port.\";\"JackoNoteOut ScsoundPortName, kstatus, kchannel, kdata1[, kdata2]\"",
        "\"JackoOn \";\"Jacko Opcodes\";\"Enables or disables all Jack ports.\";\"JackoOn [iactive]\"",
        "\"JackoTransport \";\"Jacko Opcodes\";\"Control the Jack transport.\";\"JackoTransport kcommand, [kposition]\"",
        "\"lua_exec\";\"Lua Opcodes\";\"Executes an arbitrary block of Lua code from the Csound orchestra.\";\"lua_exec Sluacode\"",
        "\"lua_iopcall\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_iopcall Sname, ...\"",
        "\"lua_ikopcall\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_ikopcall Sname, ...\"",
        "\"lua_iaopcall\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_iaopcall Sname, ...\"",
        "\"lua_iopcall_off\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_iopcall_off Sname, ...\"",
        "\"lua_ikopcall_off\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_ikopcall_off Sname, ...\"",
        "\"lua_iaopcall_off\";\"Lua Opcodes\";\"Calls a Lua opcode at i-rate only. Any number of output and/or input arguments may be passed. All arguments must be passed on the right-hand side. Outputs are returned in the argument.\";\"lua_iaopcall_off Sname, ...\"",
        "\"lua_opdef\";\"Lua Opcodes\";\"Define an opcode in Lua at i-rate. The opcode can take any number of output and/or input arguments of any type.\";\"lua_opdef Sname, Sluacode\"",
        "\"serialBegin\";\"Serial I/O\";\"Open a serial port.\";\"iPort serialBegin SPortName [, ibaudRate]\"",
        "\"serialEnd\";\"Serial I/O\";\"Close a serial port.\";\"serialEnd iPort\"",
        "\"serialFlush\";\"Serial I/O\";\"Flush data from a serial port.\";\"serialFlush iPort\"",
        "\"serialPrint\";\"Serial I/O\";\"Print data from a serial port.\";\"serialPrint iPort\"",
        "\"serialRead\";\"Serial I/O\";\"Read data from a serial port.\";\"kByte serialRead iPort\"",
        "\"serialWrite\";\"Serial I/O\";\"Write data to a serial port.\";\"serialWrite iPort, iByte\"",
        "\"serialWrite_i\";\"Serial I/O\";\"Write data to a serial port.\";\"serialWrite_i iPort, iByte\"",
        "\"ftfree\";\"Table Control\";\"Deletes function table.\";\"ftfree ifno, iwhen\"",
        "\"ftgen\";\"Table Control\";\"Generate a score function table from within the orchestra.\";\"gir ftgen ifn, itime, isize, igen, iarga [, iargb ] [...]\"",
        "\"ftgentmp\";\"Table Control\";\"Generate a score function table from within the orchestra, which is deleted at the end of the note.\";\"ifno ftgentmp ip1, ip2dummy, isize, igen, iarga, iargb, ...\"",
        "\"sndload\";\"Table Control\";\"Loads a sound file into memory for use by\";\"sndload Sfname[, ifmt[, ichns[, isr[, ibas[, iamp[, istrt  [, ilpmod[, ilps[, ilpe]]]]]]]]]\"",
        "\"ftchnls\";\"Table Control:Table Queries\";\"Returns the number of channels in a stored function table.\";\"ftchnls(x) (init-rate args only)\"",
        "\"ftcps\";\"Table Control:Table Queries\";\"Returns the base frequency of a stored function table in Hz.\";\"ftcps(x) (init-rate args only)\"",
        "\"ftlen\";\"Table Control:Table Queries\";\"Returns the size of a stored function table.\";\"ftlen(x) (init-rate args only)\"",
        "\"ftlptim\";\"Table Control:Table Queries\";\"Returns the loop segment start-time of a stored function table number.\";\"ftlptim(x) (init-rate args only)\"",
        "\"ftsr\";\"Table Control:Table Queries\";\"Returns the sampling-rate of a stored function table.\";\"ftsr(x) (init-rate args only)\"",
        "\"nsamp\";\"Table Control:Table Queries\";\"Returns the number of samples loaded into a stored function table number.\";\"nsamp(x) (init-rate args only)\"",
        "\"tableng\";\"Table Control:Table Queries\";\"Interrogates a function table for length.\";\"ires tableng ifn\"",
        "\"tabsum\";\"Table Control:Table Queries\";\"Adding values in a range of a table.\";\"kr tabsum ifn[[, kmin] [, kmax]]\"",
        "\"tb0_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb0_init ifn\"",
        "\"tb1_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb1_init ifn\"",
        "\"tb2_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb2_init ifn\"",
        "\"tb3_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb3_init ifn\"",
        "\"tb4_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb4_init ifn\"",
        "\"tb5_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb5_init ifn\"",
        "\"tb6_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb6_init ifn\"",
        "\"tb7_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb7_init ifn\"",
        "\"tb8_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb8_init ifn\"",
        "\"tb9_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb9_init ifn\"",
        "\"tb10_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb10_init ifn\"",
        "\"tb11_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb11_init ifn\"",
        "\"tb12_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb12_init ifn\"",
        "\"tb13_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb13_init ifn\"",
        "\"tb14_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb14_init ifn\"",
        "\"tb15_init\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"tb15_init ifn\"",
        "\"tb0\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb0(iIndex)\"",
        "\"tb1\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb1(iIndex)\"",
        "\"tb2\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb2(iIndex)\"",
        "\"tb3\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb3(iIndex)\"",
        "\"tb4\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb4(iIndex)\"",
        "\"tb5\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb5(iIndex)\"",
        "\"tb6\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb6(iIndex)\"",
        "\"tb7\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb7(iIndex)\"",
        "\"tb8\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb8(iIndex)\"",
        "\"tb9\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb9(iIndex)\"",
        "\"tb10\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb10(iIndex)\"",
        "\"tb11\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb11(iIndex)\"",
        "\"tb12\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb12(iIndex)\"",
        "\"tb13\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb13(iIndex)\"",
        "\"tb14\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb14(iIndex)\"",
        "\"tb15\";\"Table Control:Table Queries\";\"Table Read Access inside expressions.\";\"iout = tb15(iIndex)\"",
        "\"tableikt\";\"Table Control:Dynamic Selection\";\"Provides k-rate control over table numbers.\";\"ares tableikt xndx, kfn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"tablekt\";\"Table Control:Dynamic Selection\";\"Provides k-rate control over table numbers.\";\"ares tablekt xndx, kfn [, ixmode] [, ixoff] [, iwrap]\"",
        "\"tablexkt\";\"Table Control:Dynamic Selection\";\"Reads function tables with linear, cubic, or sinc interpolation.\";\"ares tablexkt xndx, kfn, kwarp, iwsize [, ixmode] [, ixoff] [, iwrap]\"",
        "\"ftload\";\"Table Control:Read/Write Opreations\";\"Load a set of previously-allocated tables from a file.\";\"ftload \"filename\", iflag, ifn1 [, ifn2] [...]\"",
        "\"ftloadk\";\"Table Control:Read/Write Opreations\";\"Load a set of previously-allocated tables from a file.\";\"ftloadk \"filename\", ktrig, iflag, ifn1 [, ifn2] [...]\"",
        "\"ftsave\";\"Table Control:Read/Write Opreations\";\"Save a set of previously-allocated tables to a file.\";\"ftsave \"filename\", iflag, ifn1 [, ifn2] [...]\"",
        "\"ftsavek\";\"Table Control:Read/Write Opreations\";\"Save a set of previously-allocated tables to a file.\";\"ftsavek \"filename\", ktrig, iflag, ifn1 [, ifn2] [...]\"",
        "\"ptablew\";\"Table Control:Read/Write Opreations\";\"Change the contents of existing function tables of any length.\";\"ptablew asig, andx, ifn [, ixmode] [, ixoff] [, iwgmode]\"",
        "\"tablecopy\";\"Table Control:Read/Write Opreations\";\"Simple, fast table copy opcode.\";\"tablecopy kdft, ksft\"",
        "\"tablegpw\";\"Table Control:Read/Write Opreations\";\"Writes a table's guard point.\";\"tablegpw kfn\"",
        "\"tableicopy\";\"Table Control:Read/Write Opreations\";\"Simple, fast table copy opcode.\";\"tableicopy idft, isft\"",
        "\"tableigpw\";\"Table Control:Read/Write Opreations\";\"Writes a table's guard point.\";\"tableigpw ifn\"",
        "\"tableimix\";\"Table Control:Read/Write Opreations\";\"Mixes two tables.\";\"tableimix idft, idoff, ilen, is1ft, is1off, is1g, is2ft, is2off, is2g\"",
        "\"tableiw\";\"Table Control:Read/Write Opreations\";\"Change the contents of existing function tables.\";\"tableiw isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode]\"",
        "\"tablemix\";\"Table Control:Read/Write Opreations\";\"Mixes two tables.\";\"tablemix kdft, kdoff, klen, ks1ft, ks1off, ks1g, ks2ft, ks2off, ks2g\"",
        "\"tablera\";\"Table Control:Read/Write Opreations\";\"Reads tables in sequential locations.\";\"ares tablera kfn, kstart, koff\"",
        "\"tablew\";\"Table Control:Read/Write Opreations\";\"Change the contents of existing function tables.\";\"tablew asig, andx, ifn [, ixmode] [, ixoff] [, iwgmode]\"",
        "\"tablewa\";\"Table Control:Read/Write Opreations\";\"Writes tables in sequential locations.\";\"kstart tablewa kfn, asig, koff\"",
        "\"tablewkt\";\"Table Control:Read/Write Opreations\";\"Change the contents of existing function tables.\";\"tablewkt asig, andx, kfn [, ixmode] [, ixoff] [, iwgmode]\"",
        "\"tabmorph\";\"Table Control:Read/Write Opreations\";\"Allow morphing between a set of tables.\";\"kout tabmorph kindex, kweightpoint, ktabnum1, ktabnum2,  ifn1, ifn2 [, ifn3, ifn4, ...,ifnN]\"",
        "\"tabmorpha\";\"Table Control:Read/Write Opreations\";\"Allow morphing between a set of tables at audio rate with interpolation.\";\"aout tabmorpha aindex, aweightpoint, atabnum1, atabnum2,  ifn1, ifn2 [, ifn3, ifn4, ... ifnN]\"",
        "\"tabmorphak\";\"Table Control:Read/Write Opreations\";\"Allow morphing between a set of tables at audio rate with interpolation.\";\"aout tabmorphak aindex, kweightpoint, ktabnum1, ktabnum2,  ifn1, ifn2 [, ifn3, ifn4, ... ifnN]\"",
        "\"tabmorphi\";\"Table Control:Read/Write Opreations\";\"Allow morphing between a set of tables with interpolation.\";\"kout tabmorphi kindex, kweightpoint, ktabnum1, ktabnum2,  ifn1, ifn2 [, ifn3, ifn4, ..., ifnN]\"",
        "\"tabplay\";\"Table Control:Read/Write Opreations\";\"Playing-back control signals.\";\"tabplay ktrig, knumtics, kfn, kout1 [,kout2,..., koutN]\"",
        "\"tabrec\";\"Table Control:Read/Write Opreations\";\"Recording of control signals.\";\"tabrec ktrig_start, ktrig_stop, knumtics, kfn, kin1 [,kin2,...,kinN]\"",
        "\"FLgroup\";\"FLTK:Containers\";\"A FLTK container opcode that groups child widgets.\";\"FLgroup \"label\", iwidth, iheight, ix, iy [, iborder] [, image]\"",
        "\"FLgroupEnd\";\"FLTK:Containers\";\"Marks the end of a group of FLTK child widgets.\";\"FLgroupEnd\"",
        "\"FLpack\";\"FLTK:Containers\";\"Provides the functionality of compressing and aligning FLTK widgets.\";\"FLpack iwidth, iheight, ix, iy, itype, ispace, iborder\"",
        "\"FLpackEnd\";\"FLTK:Containers\";\"Marks the end of a group of compressed or aligned FLTK widgets.\";\"FLpackEnd\"",
        "\"FLpanel\";\"FLTK:Containers\";\"Creates a window that contains FLTK widgets.\";\"FLpanel \"label\", iwidth, iheight [, ix] [, iy] [, iborder] [, ikbdcapture] [, iclose]\"",
        "\"FLpanelEnd\";\"FLTK:Containers\";\"Marks the end of a group of FLTK widgets contained inside of a window (panel).\";\"FLpanelEnd\"",
        "\"FLscroll\";\"FLTK:Containers\";\"A FLTK opcode that adds scroll bars to an area.\";\"FLscroll iwidth, iheight [, ix] [, iy]\"",
        "\"FLscrollEnd\";\"FLTK:Containers\";\"A FLTK opcode that marks the end of an area with scrollbars.\";\"FLscrollEnd\"",
        "\"FLtabs\";\"FLTK:Containers\";\"Creates a tabbed FLTK interface.\";\"FLtabs iwidth, iheight, ix, iy\"",
        "\"FLtabsEnd\";\"FLTK:Containers\";\"Marks the end of a tabbed FLTK interface.\";\"FLtabsEnd\"",
        "\"FLcount\";\"FLTK:Valuators\";\"A FLTK widget opcode that creates a counter.\";\"kout, ihandle FLcount \"label\", imin, imax, istep1, istep2, itype,  iwidth, iheight, ix, iy, iopcode [, kp1] [, kp2] [, kp3] [...] [, kpN]\"",
        "\"FLjoy\";\"FLTK:Valuators\";\"A FLTK opcode that acts like a joystick.\";\"koutx, kouty, ihandlex, ihandley FLjoy \"label\", iminx, imaxx, iminy,  imaxy, iexpx, iexpy, idispx, idispy, iwidth, iheight, ix, iy\"",
        "\"FLknob\";\"FLTK:Valuators\";\"A FLTK widget opcode that creates a knob.\";\"kout, ihandle FLknob \"label\", imin, imax, iexp, itype, idisp, iwidth,  ix, iy [, icursorsize]\"",
        "\"FLroller\";\"FLTK:Valuators\";\"A FLTK widget that creates a transversal knob.\";\"kout, ihandle FLroller \"label\", imin, imax, istep, iexp, itype, idisp,  iwidth, iheight, ix, iy\"",
        "\"FLslider\";\"FLTK:Valuators\";\"Puts a slider into the corresponding FLTK container.\";\"kout, ihandle FLslider \"label\", imin, imax, iexp, itype, idisp, iwidth,  iheight, ix, iy\"",
        "\"FLtext\";\"FLTK:Valuators\";\"A FLTK widget opcode that creates a textbox.\";\"kout, ihandle FLtext \"label\", imin, imax, istep, itype, iwidth,  iheight, ix, iy\"",
        "\"FLbox\";\"FLTK:Other\";\"A FLTK widget that displays text inside of a box.\";\"ihandle FLbox \"label\", itype, ifont, isize, iwidth, iheight, ix, iy [, image]\"",
        "\"FLbutBank\";\"FLTK:Other\";\"A FLTK widget opcode that creates a bank of buttons.\";\"kout, ihandle FLbutBank itype, inumx, inumy, iwidth, iheight, ix, iy,  iopcode [, kp1] [, kp2] [, kp3] [, kp4] [, kp5] [....] [, kpN]\"",
        "\"FLbutton\";\"FLTK:Other\";\"A FLTK widget opcode that creates a button.\";\"kout, ihandle FLbutton \"label\", ion, ioff, itype, iwidth, iheight, ix,  iy, iopcode [, kp1] [, kp2] [, kp3] [, kp4] [, kp5] [....] [, kpN]\"",
        "\"FLcloseButton\";\"FLTK:Other\";\"A FLTK widget opcode that creates a button that will close the panel window it is a part of.\";\"ihandle FLcloseButton \"label\", iwidth, iheight, ix, iy\"",
        "\"FLexecButton\";\"FLTK:Other\";\"A FLTK widget opcode that creates a button that executes a command.\";\"ihandle FLexecButton \"command\", iwidth, iheight, ix, iy\"",
        "\"FLgetsnap\";\"FLTK:Other\";\"Retrieves a previously stored FLTK snapshot.\";\"inumsnap FLgetsnap index [, igroup]\"",
        "\"FLhvsBox\";\"FLTK:Other\";\"Displays a box with a grid useful for visualizing two-dimensional Hyper Vectorial Synthesis.\";\"ihandle FLhvsBox inumlinesX, inumlinesY, iwidth, iheight, ix, iy [, image]\"",
        "\"FLkeyIn\";\"FLTK:Other\";\"Reports keys pressed (on alphanumeric keyboard) when an FLTK panel has focus.\";\"kascii FLkeyIn [ifn]\"",
        "\"FLloadsnap\";\"FLTK:Other\";\"Loads all snapshots into the memory bank of the current orchestra.\";\"FLloadsnap \"filename\" [, igroup]\"",
        "\"FLmouse\";\"FLTK:Other\";\"Returns the mouse position and the state of the three mouse buttons.\";\"kx, ky, kb1, kb2, kb3 FLmouse [imode]\"",
        "\"FLprintk\";\"FLTK:Other\";\"A FLTK opcode that prints a k-rate value at specified intervals.\";\"FLprintk itime, kval, idisp\"",
        "\"FLprintk2\";\"FLTK:Other\";\"A FLTK opcode that prints a new value every time a control-rate variable changes.\";\"FLprintk2 kval, idisp\"",
        "\"FLrun\";\"FLTK:Other\";\"Starts the FLTK widget thread.\";\"FLrun\"",
        "\"FLsavesnap\";\"FLTK:Other\";\"Saves all snapshots currently created into a file.\";\"FLsavesnap \"filename\" [, igroup]\"",
        "\"FLsetsnap\";\"FLTK:Other\";\"Stores the current status of all FLTK valuators into a snapshot location.\";\"inumsnap, inumval FLsetsnap index [, ifn, igroup]\"",
        "\"FLsetSnapGroup\";\"FLTK:Other\";\"Determines the snapshot group for FL valuators.\";\"FLsetSnapGroup igroup\"",
        "\"FLsetVal\";\"FLTK:Other\";\"Sets the value of a FLTK valuator at control-rate.\";\"FLsetVal ktrig, kvalue, ihandle\"",
        "\"FLsetVal_i\";\"FLTK:Other\";\"Sets the value of a FLTK valuator to a number provided by the user.\";\"FLsetVal_i ivalue, ihandle\"",
        "\"FLslidBnk\";\"FLTK:Other\";\"A FLTK widget containing a bank of horizontal sliders.\";\"FLslidBnk \"names\", inumsliders [, ioutable] [, iwidth] [, iheight] [, ix]  [, iy] [, itypetable] [, iexptable] [, istart_index] [, iminmaxtable]\"",
        "\"FLslidBnk2\";\"FLTK:Other\";\"A FLTK widget containing a bank of horizontal sliders.\";\"FLslidBnk2 \"names\", inumsliders, ioutable, iconfigtable [,iwidth, iheight, ix, iy, istart_index]\"",
        "\"FLslidBnk2Set\";\"FLTK:Other\";\"modify the values of a slider bank.\";\"FLslidBnk2Set ihandle, ifn [, istartIndex, istartSlid, inumSlid]\"",
        "\"FLslidBnk2Setk\";\"FLTK:Other\";\"modify the values of a slider bank.\";\"FLslidBnk2Setk ktrig, ihandle, ifn [, istartIndex, istartSlid, inumSlid]\"",
        "\"FLslidBnkGetHandle\";\"FLTK:Other\";\"gets the handle of last slider bank created.\";\"ihandle FLslidBnkGetHandle\"",
        "\"FLslidBnkSet\";\"FLTK:Other\";\"modify the values of a slider bank.\";\"FLslidBnkSet ihandle, ifn [, istartIndex, istartSlid, inumSlid]\"",
        "\"FLslidBnkSetk\";\"FLTK:Other\";\"modify the values of a slider bank.\";\"FLslidBnkSetk ktrig, ihandle, ifn [, istartIndex, istartSlid, inumSlid]\"",
        "\"FLupdate\";\"FLTK:Other\";\"Same as the FLrun opcode.\";\"FLupdate\"",
        "\"FLvalue\";\"FLTK:Other\";\"Shows the current value of a FLTK valuator.\";\"ihandle FLvalue \"label\", iwidth, iheight, ix, iy\"",
        "\"FLvkeybd\";\"FLTK:Other\";\"An FLTK widget opcode that creates a virtual keyboard widget.\";\"FLvkeybd \"keyboard.map\", iwidth, iheight, ix, iy\"",
        "\"FLvslidBnk\";\"FLTK:Other\";\"A FLTK widget containing a bank of vertical sliders.\";\"FLvslidBnk \"names\", inumsliders [, ioutable] [, iwidth] [, iheight] [, ix]  [, iy] [, itypetable] [, iexptable] [, istart_index] [, iminmaxtable]\"",
        "\"FLvslidBnk2\";\"FLTK:Other\";\"A FLTK widget containing a bank of vertical sliders.\";\"FLvslidBnk2 \"names\", inumsliders, ioutable, iconfigtable [,iwidth, iheight, ix, iy, istart_index]\"",
        "\"FLxyin\";\"FLTK:Other\";\"Senses the mouse cursor position in a user-defined area inside an FLpanel.\";\"koutx, kouty, kinside FLxyin ioutx_min, ioutx_max, iouty_min, iouty_max,  iwindx_min, iwindx_max, iwindy_min, iwindy_max [, iexpx, iexpy, ioutx, iouty]\"",
        "\"vphaseseg\";\"FLTK:Other\";\"Allows one-dimensional HVS (Hyper-Vectorial Synthesis).\";\"vphaseseg kphase, ioutab, ielems, itab1,idist1,itab2  [,idist2,itab3, ... ,idistN-1,itabN]\"",
        "\"FLcolor\";\"FLTK:Appearance\";\"A FLTK opcode that sets the primary colors.\";\"FLcolor ired, igreen, iblue [, ired2, igreen2, iblue2]\"",
        "\"FLcolor2\";\"FLTK:Appearance\";\"A FLTK opcode that sets the secondary (selection) color.\";\"FLcolor2 ired, igreen, iblue\"",
        "\"FLhide\";\"FLTK:Appearance\";\"Hides the target FLTK widget.\";\"FLhide ihandle\"",
        "\"FLlabel\";\"FLTK:Appearance\";\"A FLTK opcode that modifies the appearance of a text label.\";\"FLlabel isize, ifont, ialign, ired, igreen, iblue\"",
        "\"FLsetAlign\";\"FLTK:Appearance\";\"Sets the text alignment of a label of a FLTK widget.\";\"FLsetAlign ialign, ihandle\"",
        "\"FLsetBox\";\"FLTK:Appearance\";\"Sets the appearance of a box surrounding a FLTK widget.\";\"FLsetBox itype, ihandle\"",
        "\"FLsetColor\";\"FLTK:Appearance\";\"Sets the primary color of a FLTK widget.\";\"FLsetColor ired, igreen, iblue, ihandle\"",
        "\"FLsetColor2\";\"FLTK:Appearance\";\"Sets the secondary (or selection) color of a FLTK widget.\";\"FLsetColor2 ired, igreen, iblue, ihandle\"",
        "\"FLsetFont\";\"FLTK:Appearance\";\"Sets the font type of a FLTK widget.\";\"FLsetFont ifont, ihandle\"",
        "\"FLsetPosition\";\"FLTK:Appearance\";\"Sets the position of a FLTK widget.\";\"FLsetPosition ix, iy, ihandle\"",
        "\"FLsetSize\";\"FLTK:Appearance\";\"Resizes a FLTK widget.\";\"FLsetSize iwidth, iheight, ihandle\"",
        "\"FLsetText\";\"FLTK:Appearance\";\"Sets the label of a FLTK widget.\";\"FLsetText \"itext\", ihandle\"",
        "\"FLsetTextColor\";\"FLTK:Appearance\";\"Sets the color of the text label of a FLTK widget.\";\"FLsetTextColor ired, iblue, igreen, ihandle\"",
        "\"FLsetTextSize\";\"FLTK:Appearance\";\"Sets the size of the text label of a FLTK widget.\";\"FLsetTextSize isize, ihandle\"",
        "\"FLsetTextType\";\"FLTK:Appearance\";\"Sets some font attributes of the text label of a FLTK widget.\";\"FLsetTextType itype, ihandle\"",
        "\"FLshow\";\"FLTK:Appearance\";\"Restores the visibility of a previously hidden FLTK widget.\";\"FLshow ihandle\"",
        "\"clear\";\"Mathematical Operations:Comparators and Accumulators\";\"Zeroes a list of audio signals.\";\"clear avar1 [, avar2] [, avar3] [...]\"",
        "\"vincr\";\"Mathematical Operations:Comparators and Accumulators\";\"Accumulates audio signals.\";\"vincr accum, aincr\"",
        "\"abs\";\"Mathematical Operations:Mathematical Functions\";\"Returns an absolute value.\";\"abs(x) (no rate restriction)\"",
        "\"ceil\";\"Mathematical Operations:Mathematical Functions\";\"Returns the smallest integer not less than\";\"ceil(x) (init-, control-, or audio-rate arg allowed)\"",
        "\"exp\";\"Mathematical Operations:Mathematical Functions\";\"Returns e raised to the x-th power.\";\"exp(x) (no rate restriction)\"",
        "\"floor\";\"Mathematical Operations:Mathematical Functions\";\"Returns the largest integer not greater than\";\"floor(x) (init-, control-, or audio-rate arg allowed)\"",
        "\"frac\";\"Mathematical Operations:Mathematical Functions\";\"Returns the fractional part of a decimal number.\";\"frac(x) (init-rate or control-rate args, also works at audio rate in Csound5)\"",
        "\"int\";\"Mathematical Operations:Mathematical Functions\";\"Extracts an integer from a decimal number.\";\"int(x) (init-rate or control-rate, also works at audio rate in Csound5)\"",
        "\"log\";\"Mathematical Operations:Mathematical Functions\";\"Returns a natural log.\";\"log(x) (no rate restriction)\"",
        "\"log10\";\"Mathematical Operations:Mathematical Functions\";\"Returns a base 10 log.\";\"log10(x) (no rate restriction)\"",
        "\"logbtwo\";\"Mathematical Operations:Mathematical Functions\";\"Performs a logarithmic base two calculation.\";\"logbtwo(x) (init-rate or control-rate args only)\"",
        "\"powoftwo\";\"Mathematical Operations:Mathematical Functions\";\"Performs a power-of-two calculation.\";\"powoftwo(x) (init-rate or control-rate args only)\"",
        "\"round\";\"Mathematical Operations:Mathematical Functions\";\"Returns the integer value nearest to\";\"round(x) (init-, control-, or audio-rate arg allowed)\"",
        "\"sqrt\";\"Mathematical Operations:Mathematical Functions\";\"Returns a square root value.\";\"sqrt(x) (no rate restriction)\"",
        "\"cos\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a cosine function.\";\"cos(x) (no rate restriction)\"",
        "\"cosh\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a hyperbolic cosine function.\";\"cosh(x) (no rate restriction)\"",
        "\"cosinv\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a arccosine function.\";\"cosinv(x) (no rate restriction)\"",
        "\"sin\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a sine function.\";\"sin(x) (no rate restriction)\"",
        "\"sinh\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a hyperbolic sine function.\";\"sinh(x) (no rate restriction)\"",
        "\"sininv\";\"Mathematical Operations:Trigonometric Functions\";\"Performs an arcsine function.\";\"sininv(x) (no rate restriction)\"",
        "\"tan\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a tangent function.\";\"tan(x) (no rate restriction)\"",
        "\"tanh\";\"Mathematical Operations:Trigonometric Functions\";\"Performs a hyperbolic tangent function.\";\"tanh(x) (no rate restriction)\"",
        "\"taninv\";\"Mathematical Operations:Trigonometric Functions\";\"Performs an arctangent function.\";\"taninv(x) (no rate restriction)\"",
        "\"ampdb\";\"Mathematical Operations:Amplitude Functions\";\"Returns the amplitude equivalent of the decibel value x.\";\"ampdb(x) (no rate restriction)\"",
        "\"ampdbfs\";\"Mathematical Operations:Amplitude Functions\";\"Returns the amplitude equivalent (in 16-bit signed integer scale) of the full scale decibel (dB FS) value\";\"ampdbfs(x) (no rate restriction)\"",
        "\"db\";\"Mathematical Operations:Amplitude Functions\";\"Returns the amplitude equivalent for a given decibel amount.\";\"db(x)\"",
        "\"dbamp\";\"Mathematical Operations:Amplitude Functions\";\"Returns the decibel equivalent of the raw amplitude\";\"dbamp(x) (init-rate or control-rate args only)\"",
        "\"dbfsamp\";\"Mathematical Operations:Amplitude Functions\";\"Returns the decibel equivalent of the raw amplitude\";\"dbfsamp(x) (init-rate or control-rate args only)\"",
        "\"birnd\";\"Mathematical Operations:Random Functions\";\"Returns a random number in a bi-polar range.\";\"birnd(x) (init- or control-rate only)\"",
        "\"rnd\";\"Mathematical Operations:Random Functions\";\"Returns a random number in a unipolar range at the rate given by the input argument.\";\"rnd(x) (init- or control-rate only)\"",
        "\"divz\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Safely divides two numbers.\";\"ares divz xa, xb, ksubst\"",
        "\"mac\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Multiplies and accumulates a- and k-rate signals.\";\"ares mac ksig1, asig1 [, ksig2] [, asig2] [, ksig3] [, asig3] [...]\"",
        "\"maca\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Multiply and accumulate a-rate signals only.\";\"ares maca asig1 , asig2 [, asig3] [, asig4] [, asig5] [...]\"",
        "\"polynomial\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Efficiently evaluates a polynomial of arbitrary order.\";\"aout polynomial ain, k0 [, k1 [, k2 [...]]]\"",
        "\"pow\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Computes one argument to the power of another argument.\";\"ares pow aarg, kpow [, inorm]\"",
        "\"product\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Multiplies any number of a-rate signals.\";\"ares product asig1, asig2 [, asig3] [...]\"",
        "\"sum\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Sums any number of a-rate signals.\";\"ares sum asig1 [, asig2] [, asig3] [...]\"",
        "\"taninv2\";\"Mathematical Operations:Opcode Equivalents of Functions\";\"Returns an arctangent.\";\"ares taninv2 ay, ax\"",
        "\"cent\";\"Pitch Converters:Functions\";\"Calculates a factor to raise/lower a frequency by a given amount of cents.\";\"cent(x)\"",
        "\"cpsmidinn\";\"Pitch Converters:Functions\";\"Converts a Midi note number value to cycles-per-second.\";\"cpsmidinn (MidiNoteNumber) (init- or control-rate args only)\"",
        "\"cpsoct\";\"Pitch Converters:Functions\";\"Converts an octave-point-decimal value to cycles-per-second.\";\"cpsoct (oct) (no rate restriction)\"",
        "\"cpspch\";\"Pitch Converters:Functions\";\"Converts a pitch-class value to cycles-per-second.\";\"cpspch (pch) (init- or control-rate args only)\"",
        "\"octave\";\"Pitch Converters:Functions\";\"Calculates a factor to raise/lower a frequency by a given amount of octaves.\";\"octave(x)\"",
        "\"octcps\";\"Pitch Converters:Functions\";\"Converts a cycles-per-second value to octave-point-decimal.\";\"octcps (cps) (init- or control-rate args only)\"",
        "\"octmidinn\";\"Pitch Converters:Functions\";\"Converts a Midi note number value to octave-point-decimal.\";\"octmidinn (MidiNoteNumber) (init- or control-rate args only)\"",
        "\"octpch\";\"Pitch Converters:Functions\";\"Converts a pitch-class value to octave-point-decimal.\";\"octpch (pch) (init- or control-rate args only)\"",
        "\"pchmidinn\";\"Pitch Converters:Functions\";\"Converts a Midi note number value to octave point pitch-class units.\";\"pchmidinn (MidiNoteNumber) (init- or control-rate args only)\"",
        "\"pchoct\";\"Pitch Converters:Functions\";\"Converts an octave-point-decimal value to pitch-class.\";\"pchoct (oct) (init- or control-rate args only)\"",
        "\"semitone\";\"Pitch Converters:Functions\";\"Calculates a factor to raise/lower a frequency by a given amount of semitones.\";\"semitone(x)\"",
        "\"cps2pch\";\"Pitch Converters:Tuning Opcodes\";\"Converts a pitch-class value into cycles-per-second (Hz) for equal divisions of the octave.\";\"icps cps2pch ipch, iequal\"",
        "\"cpstun\";\"Pitch Converters:Tuning Opcodes\";\"Returns micro-tuning values at k-rate.\";\"kcps cpstun ktrig, kindex, kfn\"",
        "\"cpstuni\";\"Pitch Converters:Tuning Opcodes\";\"Returns micro-tuning values at init-rate.\";\"icps cpstuni index, ifn\"",
        "\"cpsxpch\";\"Pitch Converters:Tuning Opcodes\";\"Converts a pitch-class value into cycles-per-second (Hz) for equal divisions of any interval.\";\"icps cpsxpch ipch, iequal, irepeat, ibase\"",
        "\"aftouch\";\"Real-time MIDI:Input\";\"Get the current after-touch value for this channel.\";\"kaft aftouch [imin] [, imax]\"",
        "\"chanctrl\";\"Real-time MIDI:Input\";\"Get the current value of a MIDI channel controller.\";\"ival chanctrl ichnl, ictlno [, ilow] [, ihigh]\"",
        "\"ctrl14\";\"Real-time MIDI:Input\";\"Allows a floating-point 14-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest ctrl14 ichan, ictlno1, ictlno2, imin, imax [, ifn]\"",
        "\"ctrl21\";\"Real-time MIDI:Input\";\"Allows a floating-point 21-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest ctrl21 ichan, ictlno1, ictlno2, ictlno3, imin, imax [, ifn]\"",
        "\"ctrl7\";\"Real-time MIDI:Input\";\"Allows a floating-point 7-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest ctrl7 ichan, ictlno, imin, imax [, ifn]\"",
        "\"ctrlinit\";\"Real-time MIDI:Input\";\"Sets the initial values for a set of MIDI controllers.\";\"ctrlinit ichnl, ictlno1, ival1 [, ictlno2] [, ival2] [, ictlno3]  [, ival3] [,...ival32]\"",
        "\"initc14\";\"Real-time MIDI:Input\";\"Initializes the controllers used to create a 14-bit MIDI value.\";\"initc14 ichan, ictlno1, ictlno2, ivalue\"",
        "\"initc21\";\"Real-time MIDI:Input\";\"Initializes the controllers used to create a 21-bit MIDI value.\";\"initc21 ichan, ictlno1, ictlno2, ictlno3, ivalue\"",
        "\"initc7\";\"Real-time MIDI:Input\";\"Initializes the controller used to create a 7-bit MIDI value.\";\"initc7 ichan, ictlno, ivalue\"",
        "\"massign\";\"Real-time MIDI:Input\";\"Assigns a MIDI channel number to a Csound instrument.\";\"massign ichnl, insnum[, ireset]\"",
        "\"midic14\";\"Real-time MIDI:Input\";\"Allows a floating-point 14-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest midic14 ictlno1, ictlno2, imin, imax [, ifn]\"",
        "\"midic21\";\"Real-time MIDI:Input\";\"Allows a floating-point 21-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest midic21 ictlno1, ictlno2, ictlno3, imin, imax [, ifn]\"",
        "\"midic7\";\"Real-time MIDI:Input\";\"Allows a floating-point 7-bit MIDI signal scaled with a minimum and a maximum range.\";\"idest midic7 ictlno, imin, imax [, ifn]\"",
        "\"midictrl\";\"Real-time MIDI:Input\";\"Get the current value (0-127) of a specified MIDI controller.\";\"ival midictrl inum [, imin] [, imax]\"",
        "\"notnum\";\"Real-time MIDI:Input\";\"Get a note number from a MIDI event.\";\"ival notnum\"",
        "\"pchbend\";\"Real-time MIDI:Input\";\"Get the current pitch-bend value for this channel.\";\"ibend pchbend [imin] [, imax]\"",
        "\"pgmassign\";\"Real-time MIDI:Input\";\"Assigns an instrument number to a specified MIDI program.\";\"pgmassign ipgm, inst[, ichn]\"",
        "\"polyaft\";\"Real-time MIDI:Input\";\"Returns the polyphonic after-touch pressure of the selected note number.\";\"ires polyaft inote [, ilow] [, ihigh]\"",
        "\"veloc\";\"Real-time MIDI:Input\";\"Get the velocity from a MIDI event.\";\"ival veloc [ilow] [, ihigh]\"",
        "\"nrpn\";\"Real-time MIDI:Output\";\"Sends a Non-Registered Parameter Number to the MIDI OUT port.\";\"nrpn kchan, kparmnum, kparmvalue\"",
        "\"outiat\";\"Real-time MIDI:Output\";\"Sends MIDI aftertouch messages at i-rate.\";\"outiat ichn, ivalue, imin, imax\"",
        "\"outic\";\"Real-time MIDI:Output\";\"Sends MIDI controller output at i-rate.\";\"outic ichn, inum, ivalue, imin, imax\"",
        "\"outic14\";\"Real-time MIDI:Output\";\"Sends 14-bit MIDI controller output at i-rate.\";\"outic14 ichn, imsb, ilsb, ivalue, imin, imax\"",
        "\"outipat\";\"Real-time MIDI:Output\";\"Sends polyphonic MIDI aftertouch messages at i-rate.\";\"outipat ichn, inotenum, ivalue, imin, imax\"",
        "\"outipb\";\"Real-time MIDI:Output\";\"Sends MIDI pitch-bend messages at i-rate.\";\"outipb ichn, ivalue, imin, imax\"",
        "\"outipc\";\"Real-time MIDI:Output\";\"Sends MIDI program change messages at i-rate\";\"outipc ichn, iprog, imin, imax\"",
        "\"outkat\";\"Real-time MIDI:Output\";\"Sends MIDI aftertouch messages at k-rate.\";\"outkat kchn, kvalue, kmin, kmax\"",
        "\"outkc\";\"Real-time MIDI:Output\";\"Sends MIDI controller messages at k-rate.\";\"outkc kchn, knum, kvalue, kmin, kmax\"",
        "\"outkc14\";\"Real-time MIDI:Output\";\"Sends 14-bit MIDI controller output at k-rate.\";\"outkc14 kchn, kmsb, klsb, kvalue, kmin, kmax\"",
        "\"outkpat\";\"Real-time MIDI:Output\";\"Sends polyphonic MIDI aftertouch messages at k-rate.\";\"outkpat kchn, knotenum, kvalue, kmin, kmax\"",
        "\"outkpb\";\"Real-time MIDI:Output\";\"Sends MIDI pitch-bend messages at k-rate.\";\"outkpb kchn, kvalue, kmin, kmax\"",
        "\"outkpc\";\"Real-time MIDI:Output\";\"Sends MIDI program change messages at k-rate.\";\"outkpc kchn, kprog, kmin, kmax\"",
        "\"ampmidi\";\"Real-time MIDI:Converters\";\"Get the velocity of the current MIDI event.\";\"iamp ampmidi iscal [, ifn]\"",
        "\"ampmidid\";\"Real-time MIDI:Converters\";\"Musically map MIDI velocity to peak amplitude within a specified dynamic range in decibels.\";\"iamplitude ampmidid ivelocity, idecibels\"",
        "\"cpsmidi\";\"Real-time MIDI:Converters\";\"Get the note number of the current MIDI event, expressed in cycles-per-second.\";\"icps cpsmidi\"",
        "\"cpsmidib\";\"Real-time MIDI:Converters\";\"Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in cycles-per-second.\";\"icps cpsmidib [irange]\"",
        "\"cpstmid\";\"Real-time MIDI:Converters\";\"Get a MIDI note number (allows customized micro-tuning scales).\";\"icps cpstmid ifn\"",
        "\"octmidi\";\"Real-time MIDI:Converters\";\"Get the note number, in octave-point-decimal units, of the current MIDI event.\";\"ioct octmidi\"",
        "\"octmidib\";\"Real-time MIDI:Converters\";\"Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in octave-point-decimal.\";\"ioct octmidib [irange]\"",
        "\"pchmidi\";\"Real-time MIDI:Converters\";\"Get the note number of the current MIDI event, expressed in pitch-class units.\";\"ipch pchmidi\"",
        "\"pchmidib\";\"Real-time MIDI:Converters\";\"Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in pitch-class units.\";\"ipch pchmidib [irange]\"",
        "\"midiin\";\"Real-time MIDI:Generic I/O\";\"Returns a generic MIDI message received by the MIDI IN port.\";\"kstatus, kchan, kdata1, kdata2 midiin\"",
        "\"midiout\";\"Real-time MIDI:Generic I/O\";\"Sends a generic MIDI message to the MIDI OUT port.\";\"midiout kstatus, kchan, kdata1, kdata2\"",
        "\"release\";\"Real-time MIDI:Event Extenders\";\"Indicates whether a note is in its\";\"kflag release\"",
        "\"xtratim\";\"Real-time MIDI:Event Extenders\";\"Extend the duration of real-time generated events.\";\"xtratim iextradur\"",
        "\"midion\";\"Real-time MIDI:Note Output\";\"Generates MIDI note messages at k-rate.\";\"midion kchn, knum, kvel\"",
        "\"midion2\";\"Real-time MIDI:Note Output\";\"Sends noteon and noteoff messages to the MIDI OUT port.\";\"midion2 kchn, knum, kvel, ktrig\"",
        "\"moscil\";\"Real-time MIDI:Note Output\";\"Sends a stream of the MIDI notes.\";\"moscil kchn, knum, kvel, kdur, kpause\"",
        "\"noteoff\";\"Real-time MIDI:Note Output\";\"Send a noteoff message to the MIDI OUT port.\";\"noteoff ichn, inum, ivel\"",
        "\"noteon\";\"Real-time MIDI:Note Output\";\"Send a noteon message to the MIDI OUT port.\";\"noteon ichn, inum, ivel\"",
        "\"noteondur\";\"Real-time MIDI:Note Output\";\"Sends a noteon and a noteoff MIDI message both with the same channel, number and velocity.\";\"noteondur ichn, inum, ivel, idur\"",
        "\"noteondur2\";\"Real-time MIDI:Note Output\";\"Sends a noteon and a noteoff MIDI message both with the same channel, number and velocity.\";\"noteondur2 ichn, inum, ivel, idur\"",
        "\"midichannelaftertouch\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI channel's aftertouch value.\";\"midichannelaftertouch xchannelaftertouch [, ilow] [, ihigh]\"",
        "\"midichn\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Returns the MIDI channel number from which the note was activated.\";\"ichn midichn\"",
        "\"midicontrolchange\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI control change value.\";\"midicontrolchange xcontroller, xcontrollervalue [, ilow] [, ihigh]\"",
        "\"mididefault\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Changes values, depending on MIDI activation.\";\"mididefault xdefault, xvalue\"",
        "\"midinoteoff\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI noteoff value.\";\"midinoteoff xkey, xvelocity\"",
        "\"midinoteoncps\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI note number as a cycles-per-second frequency.\";\"midinoteoncps xcps, xvelocity\"",
        "\"midinoteonkey\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI note number value.\";\"midinoteonkey xkey, xvelocity\"",
        "\"midinoteonoct\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI note number value as octave-point-decimal value.\";\"midinoteonoct xoct, xvelocity\"",
        "\"midinoteonpch\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI note number as a pitch-class value.\";\"midinoteonpch xpch, xvelocity\"",
        "\"midipitchbend\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI pitchbend value.\";\"midipitchbend xpitchbend [, ilow] [, ihigh]\"",
        "\"midipolyaftertouch\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI polyphonic aftertouch value.\";\"midipolyaftertouch xpolyaftertouch, xcontrollervalue [, ilow] [, ihigh]\"",
        "\"midiprogramchange\";\"Real-time MIDI:MIDI/Score Interoperability\";\"Gets a MIDI program change value.\";\"midiprogramchange xprogram\"",
        "\"mclock\";\"Real-time MIDI:System Realtime\";\"Sends a MIDI CLOCK message.\";\"mclock ifreq\"",
        "\"mrtmsg\";\"Real-time MIDI:System Realtime\";\"Send system real-time messages to the MIDI OUT port.\";\"mrtmsg imsgtype\"",
        "\"s16b14\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 16 different 14-bit MIDI control message numbers.\";\"i1,...,i16 s16b14 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1,  initvalue1, ifn1,..., ictlno_msb16, ictlno_lsb16, imin16, imax16, initvalue16, ifn16\"",
        "\"s32b14\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 32 different 14-bit MIDI control message numbers.\";\"i1,...,i32 s32b14 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1,  initvalue1, ifn1,..., ictlno_msb32, ictlno_lsb32, imin32, imax32, initvalue32, ifn32\"",
        "\"slider16\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 16 different MIDI control message numbers.\";\"i1,...,i16 slider16 ichan, ictlnum1, imin1, imax1, init1, ifn1,...,  ictlnum16, imin16, imax16, init16, ifn16\"",
        "\"slider16f\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 16 different MIDI control message numbers, filtered before output.\";\"k1,...,k16 slider16f ichan, ictlnum1, imin1, imax1, init1, ifn1,  icutoff1,..., ictlnum16, imin16, imax16, init16, ifn16, icutoff16\"",
        "\"slider16table\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 16 different MIDI control messages to a table.\";\"kflag slider16table ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1, .... , ictlnum16, imin16, imax16, init16, ifn16\"",
        "\"slider16tablef\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 16 different MIDI control messages to a table, filtered before output.\";\"kflag slider16tablef ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1, icutoff1, .... , ictlnum16, imin16, imax16, init16, ifn16, icutoff16\"",
        "\"slider32\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 32 different MIDI control message numbers.\";\"i1,...,i32 slider32 ichan, ictlnum1, imin1, imax1, init1, ifn1,...,  ictlnum32, imin32, imax32, init32, ifn32\"",
        "\"slider32f\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 32 different MIDI control message numbers, filtered before output.\";\"k1,...,k32 slider32f ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1,  ..., ictlnum32, imin32, imax32, init32, ifn32, icutoff32\"",
        "\"slider32table\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 32 different MIDI control messages to a table.\";\"kflag slider32table ichan, ioutTable, ioffset, ictlnum1, imin1,  imax1, init1, ifn1, .... , ictlnum32, imin32, imax32, init32, ifn32\"",
        "\"slider32tablef\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 32 different MIDI control messages to a table, filtered before output.\";\"kflag slider32tablef ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1, icutoff1, .... , ictlnum32, imin32, imax32, init32, ifn32, icutoff32\"",
        "\"slider64\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 64 different MIDI control message numbers.\";\"i1,...,i64 slider64 ichan, ictlnum1, imin1, imax1, init1, ifn1,...,  ictlnum64, imin64, imax64, init64, ifn64\"",
        "\"slider64f\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 64 different MIDI control message numbers, filtered before output.\";\"k1,...,k64 slider64f ichan, ictlnum1, imin1, imax1, init1, ifn1,  icutoff1,..., ictlnum64, imin64, imax64, init64, ifn64, icutoff64\"",
        "\"slider64table\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 64 different MIDI control messages to a table.\";\"kflag slider64table ichan, ioutTable, ioffset, ictlnum1, imin1,  imax1, init1, ifn1, .... , ictlnum64, imin64, imax64, init64, ifn64\"",
        "\"slider64tablef\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 64 different MIDI control messages to a table, filtered before output.\";\"kflag slider64tablef ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1, icutoff1, .... , ictlnum64, imin64, imax64, init64, ifn64, icutoff64\"",
        "\"slider8\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 8 different MIDI control message numbers.\";\"i1,...,i8 slider8 ichan, ictlnum1, imin1, imax1, init1, ifn1,...,  ictlnum8, imin8, imax8, init8, ifn8\"",
        "\"slider8f\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 8 different MIDI control message numbers, filtered before output.\";\"k1,...,k8 slider8f ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1,  ..., ictlnum8, imin8, imax8, init8, ifn8, icutoff8\"",
        "\"slider8table\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 8 different MIDI control messages to a table.\";\"kflag slider8table ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1,..., ictlnum8, imin8, imax8, init8, ifn8\"",
        "\"slider8tablef\";\"Real-time MIDI:Slider Banks\";\"Stores a bank of 8 different MIDI control messages to a table, filtered before output.\";\"kflag slider8tablef ichan, ioutTable, ioffset, ictlnum1, imin1, imax1,  init1, ifn1, icutoff1, .... , ictlnum8, imin8, imax8, init8, ifn8, icutoff8\"",
        "\"sliderKawai\";\"Real-time MIDI:Slider Banks\";\"Creates a bank of 16 different MIDI control message numbers from a KAWAI MM-16 midi mixer.\";\"k1, k2, ...., k16 sliderKawai imin1, imax1, init1, ifn1,  imin2, imax2, init2, ifn2, ..., imin16, imax16, init16, ifn16\"",
        "\"alwayson\";\"Signal Flow Graph Opcodes\";\"Activates the indicated instrument in the orchestra header, without need for an i statement.\";\"alwayson Tinstrument [p4, ..., pn]\"",
        "\"connect \";\"Signal Flow Graph Opcodes\";\"Connects a source outlet to a sink inlet.\";\"connect Tsource1, Soutlet1, Tsink1, Sinlet1\"",
        "\"ftgenonce\";\"Signal Flow Graph Opcodes\";\"Generate a score function table from within the orchestra, which is deleted at the end of the note.\";\"ifno ftgenonce ip1, ip2dummy, isize, igen, iarga, iargb, ...\"",
        "\"inleta \";\"Signal Flow Graph Opcodes\";\"Receives an arate signal into an instrument through a named port.\";\"asignal inleta Sname\"",
        "\"inletf \";\"Signal Flow Graph Opcodes\";\"Receives an frate signal (fsig) into an instrument from a named port.\";\"fsignal inletf Sname\"",
        "\"inletk \";\"Signal Flow Graph Opcodes\";\"Receives a krate signal into an instrument from a named port.\";\"ksignal inletk Sname\"",
        "\"inletkid \";\"Signal Flow Graph Opcodes\";\"Receives a krate signal into an instrument from a named port.\";\"ksignal inletkid Sname, SinstanceID\"",
        "\"outleta \";\"Signal Flow Graph Opcodes\";\"Sends an arate signal out from an instrument to a named port.\";\"outleta Sname, asignal\"",
        "\"outletf \";\"Signal Flow Graph Opcodes\";\"Sends a frate signal (fsig) out from an instrument to a named port.\";\"outletf Sname, fsignal\"",
        "\"outletk \";\"Signal Flow Graph Opcodes\";\"Sends a krate signal out from an instrument to a named port.\";\"outletk Sname, ksignal\"",
        "\"outletkid \";\"Signal Flow Graph Opcodes\";\"Sends a krate signal out from an instrument to a named port.\";\"outletkid Sname, SinstanceID, ksignal\"",
        "\"ktableseg\";\"Spectral Processing:STFT\";\"Deprecated.\";\"ktableseg ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]\"",
        "\"pvadd\";\"Spectral Processing:STFT\";\"Reads from a\";\"ares pvadd ktimpnt, kfmod, ifilcod, ifn, ibins [, ibinoffset]  [, ibinincr] [, iextractmode] [, ifreqlim] [, igatefn]\"",
        "\"pvbufread\";\"Spectral Processing:STFT\";\"Reads from a phase vocoder analysis file and makes the retrieved data available.\";\"pvbufread ktimpnt, ifile\"",
        "\"pvcross\";\"Spectral Processing:STFT\";\"Applies the amplitudes from one phase vocoder analysis file to the data from a second file.\";\"ares pvcross ktimpnt, kfmod, ifile, kampscale1, kampscale2 [, ispecwp]\"",
        "\"pvinterp\";\"Spectral Processing:STFT\";\"Interpolates between the amplitudes and frequencies of two phase vocoder analysis files.\";\"ares pvinterp ktimpnt, kfmod, ifile, kfreqscale1, kfreqscale2,  kampscale1, kampscale2, kfreqinterp, kampinterp\"",
        "\"pvoc\";\"Spectral Processing:STFT\";\"Implements signal reconstruction using an fft-based phase vocoder.\";\"ares pvoc ktimpnt, kfmod, ifilcod [, ispecwp] [, iextractmode]  [, ifreqlim] [, igatefn]\"",
        "\"pvread\";\"Spectral Processing:STFT\";\"Reads from a phase vocoder analysis file and returns the frequency and amplitude from a single analysis channel or bin.\";\"kfreq, kamp pvread ktimpnt, ifile, ibin\"",
        "\"tableseg\";\"Spectral Processing:STFT\";\"Creates a new function table by making linear segments between values in stored function tables.\";\"tableseg ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]\"",
        "\"tablexseg\";\"Spectral Processing:STFT\";\"Creates a new function table by making exponential segments between values in stored function tables.\";\"tablexseg ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]\"",
        "\"vpvoc\";\"Spectral Processing:STFT\";\"Implements signal reconstruction using an fft-based phase vocoder and an extra envelope.\";\"ares vpvoc ktimpnt, kfmod, ifile [, ispecwp] [, ifn]\"",
        "\"lpfreson\";\"Spectral Processing:LPC\";\"Resynthesises a signal from the data passed internally by a previous lpread, applying formant shifting.\";\"ares lpfreson asig, kfrqratio\"",
        "\"lpinterp\";\"Spectral Processing:LPC\";\"Computes a new set of poles from the interpolation between two analysis.\";\"lpinterp islot1, islot2, kmix\"",
        "\"lpread\";\"Spectral Processing:LPC\";\"Reads a control file of time-ordered information frames.\";\"krmsr, krmso, kerr, kcps lpread ktimpnt, ifilcod [, inpoles] [, ifrmrate]\"",
        "\"lpreson\";\"Spectral Processing:LPC\";\"Resynthesises a signal from the data passed internally by a previous lpread.\";\"ares lpreson asig\"",
        "\"lpslot\";\"Spectral Processing:LPC\";\"Selects the slot to be use by further lp opcodes.\";\"lpslot islot\"",
        "\"specaddm\";\"Spectral Processing:Non-Standard\";\"Perform a weighted add of two input spectra.\";\"wsig specaddm wsig1, wsig2 [, imul2]\"",
        "\"specdiff\";\"Spectral Processing:Non-Standard\";\"Finds the positive difference values between consecutive spectral frames.\";\"wsig specdiff wsigin\"",
        "\"specdisp\";\"Spectral Processing:Non-Standard\";\"Displays the magnitude values of the spectrum.\";\"specdisp wsig, iprd [, iwtflg]\"",
        "\"specfilt\";\"Spectral Processing:Non-Standard\";\"Filters each channel of an input spectrum.\";\"wsig specfilt wsigin, ifhtim\"",
        "\"spechist\";\"Spectral Processing:Non-Standard\";\"Accumulates the values of successive spectral frames.\";\"wsig spechist wsigin\"",
        "\"specptrk\";\"Spectral Processing:Non-Standard\";\"Estimates the pitch of the most prominent complex tone in the spectrum.\";\"koct, kamp specptrk wsig, kvar, ilo, ihi, istr, idbthresh, inptls,  irolloff [, iodd] [, iconfs] [, interp] [, ifprd] [, iwtflg]\"",
        "\"specscal\";\"Spectral Processing:Non-Standard\";\"Scales an input spectral datablock with spectral envelopes.\";\"wsig specscal wsigin, ifscale, ifthresh\"",
        "\"specsum\";\"Spectral Processing:Non-Standard\";\"Sums the magnitudes across all channels of the spectrum.\";\"ksum specsum wsig [, interp]\"",
        "\"spectrum\";\"Spectral Processing:Non-Standard\";\"Generate a constant-Q, exponentially-spaced DFT.\";\"wsig spectrum xsig, iprd, iocts, ifrqa [, iq] [, ihann] [, idbout]  [, idsprd] [, idsinrs]\"",
        "\"binit\";\"Spectral Processing:Streaming\";\"PVS tracks to amplitude+frequency conversion.\";\"fsig binit fin, isize\"",
        "\"partials\";\"Spectral Processing:Streaming\";\"Partial track spectral analysis.\";\"ftrks partials ffr, fphs, kthresh, kminpts, kmaxgap, imaxtracks\"",
        "\"pvs2tab\";\"Spectral Processing:Streaming\";\"Copies spectral data to t-variables.\";\"kframe pvs2tab tvar, fsig\"",
        "\"pvsadsyn\";\"Spectral Processing:Streaming\";\"Resynthesize using a fast oscillator-bank.\";\"ares pvsadsyn fsrc, inoscs, kfmod [, ibinoffset] [, ibinincr] [, iinit]\"",
        "\"pvsanal\";\"Spectral Processing:Streaming\";\"Generate an fsig from a mono audio source ain, using phase vocoder overlap-add analysis.\";\"fsig pvsanal ain, ifftsize, ioverlap, iwinsize, iwintype [, iformat] [, iinit]\"",
        "\"pvsarp\";\"Spectral Processing:Streaming\";\"Arpeggiate the spectral components of a streaming pv signal.\";\"fsig pvsarp fsigin, kbin, kdepth, kgain\"",
        "\"pvsbandp\";\"Spectral Processing:Streaming\";\"A band pass filter working in the spectral domain.\";\"fsig pvsbandp fsigin, xlowcut, xlowfull,  xhighfull, xhighcut[, ktype]\"",
        "\"pvsbandr\";\"Spectral Processing:Streaming\";\"A band reject filter working in the spectral domain.\";\"fsig pvsbandr fsigin, xlowcut, xlowfull,  xhighfull, xhighcut[, ktype]\"",
        "\"pvsbin\";\"Spectral Processing:Streaming\";\"Obtain the amp and freq values off a PVS signal bin.\";\"kamp, kfr pvsbin fsig, kbin\"",
        "\"pvsblur\";\"Spectral Processing:Streaming\";\"Average the amp/freq time functions of each analysis channel for a specified time.\";\"fsig pvsblur fsigin, kblurtime, imaxdel\"",
        "\"pvsbuffer\";\"Spectral Processing:Streaming\";\"This opcode creates and writes to a circular buffer for f-signals (streaming PV signals).\";\"ihandle, ktime pvsbuffer fsig, ilen\"",
        "\"pvsbufread\";\"Spectral Processing:Streaming\";\"This opcode reads a circular buffer of f-signals (streaming PV signals).\";\"fsig pvsbufread ktime, khandle[, ilo, ihi, iclear]\"",
        "\"pvsbufread2\";\"Spectral Processing:Streaming\";\"This opcode reads a circular buffer of f-signals (streaming PV signals), with binwise additional delays.\";\"fsig pvsbufread2 ktime, khandle, ift1, ift2\"",
        "\"pvscale\";\"Spectral Processing:Streaming\";\"Scale the frequency components of a pv stream.\";\"fsig pvscale fsigin, kscal[, kkeepform, kgain, kcoefs]\"",
        "\"pvscent\";\"Spectral Processing:Streaming\";\"Calculate the spectral centroid of a signal.\";\"kcent pvscent fsig\"",
        "\"pvscross\";\"Spectral Processing:Streaming\";\"Performs cross-synthesis between two source fsigs.\";\"fsig pvscross fsrc, fdest, kamp1, kamp2\"",
        "\"pvsdemix\";\"Spectral Processing:Streaming\";\"Spectral azimuth-based de-mixing of stereo sources.\";\"fsig pvsdemix fleft, fright, kpos, kwidth, ipoints\"",
        "\"pvsdiskin\";\"Spectral Processing:Streaming\";\"Read a selected channel from a PVOC-EX analysis file.\";\"fsig pvsdiskin SFname,ktscal,kgain[,ioffset, ichan]\"",
        "\"pvsdisp\";\"Spectral Processing:Streaming\";\"Displays a PVS signal as an amplitude vs. freq graph.\";\"pvsdisp fsig[, ibins, iwtflg]\"",
        "\"pvsfilter\";\"Spectral Processing:Streaming\";\"Multiply amplitudes of a pvoc stream by those of a second pvoc stream, with dynamic scaling.\";\"fsig pvsfilter fsigin, fsigfil, kdepth[, igain]\"",
        "\"pvsfread\";\"Spectral Processing:Streaming\";\"Read a selected channel from a PVOC-EX analysis file.\";\"fsig pvsfread ktimpt, ifn [, ichan]\"",
        "\"pvsfreeze\";\"Spectral Processing:Streaming\";\"Freeze the amplitude and frequency time functions of a pv stream according to a control-rate trigger.\";\"fsig pvsfreeze fsigin, kfreeza, kfreezf\"",
        "\"pvsftr\";\"Spectral Processing:Streaming\";\"Reads amplitude and/or frequency data from function tables.\";\"pvsftr fsrc, ifna [, ifnf]\"",
        "\"pvsftw\";\"Spectral Processing:Streaming\";\"Writes amplitude and/or frequency data to function tables.\";\"kflag pvsftw fsrc, ifna [, ifnf]\"",
        "\"pvsfwrite\";\"Spectral Processing:Streaming\";\"Write a fsig to a PVOCEX file.\";\"pvsfwrite fsig, ifile\"",
        "\"pvsgain\";\"Spectral Processing:Streaming\";\"Scale the amplitude of a pv stream.\";\"fsig pvsgain fsigin, kgain\"",
        "\"pvshift\";\"Spectral Processing:Streaming\";\"Shift the frequency components of a pv stream, stretching/compressing its spectrum.\";\"fsig pvshift fsigin, kshift, klowest[, kkeepform, igain, kcoefs]\"",
        "\"pvsifd\";\"Spectral Processing:Streaming\";\"Instantaneous Frequency Distribution, magnitude and phase analysis.\";\"ffr,fphs pvsifd ain, ifftsize, ihopsize, iwintype[,iscal]\"",
        "\"pvsin\";\"Spectral Processing:Streaming\";\"Retrieve an fsig from the input software bus, a pvs equivalent to chani.\";\"fsig pvsin kchan[, isize, iolap, iwinsize, iwintype, iformat]\"",
        "\"pvsinfo\";\"Spectral Processing:Streaming\";\"Get information from a PVOC-EX formatted source.\";\"ioverlap, inumbins, iwinsize, iformat pvsinfo fsrc\"",
        "\"pvsinit\";\"Spectral Processing:Streaming\";\"Initialise a spectral (f) variable to zero.\";\"fsig pvsinit isize[, iolap, iwinsize, iwintype, iformat]\"",
        "\"pvslock\";\"Spectral Processing:Streaming\";\"Frequency lock an input fsig\";\"fsig pvslock fsigin, klock\"",
        "\"pvsmaska\";\"Spectral Processing:Streaming\";\"Modify amplitudes using a function table, with dynamic scaling.\";\"fsig pvsmaska fsrc, ifn, kdepth\"",
        "\"pvsmix\";\"Spectral Processing:Streaming\";\"Mix 'seamlessly' two pv signals.\";\"fsig pvsmix fsigin1, fsigin2\"",
        "\"pvsmooth\";\"Spectral Processing:Streaming\";\"Smooth the amplitude and frequency time functions of a pv stream using parallel 1st order lowpass IIR filters with time-varying cutoff frequency.\";\"fsig pvsmooth fsigin, kacf, kfcf\"",
        "\"pvsmorph\";\"Spectral Processing:Streaming\";\"Performs morphing (or interpolation) between two source fsigs.\";\"fsig pvsmorph fsig1, fsig2, kampint, kfrqint\"",
        "\"pvsosc\";\"Spectral Processing:Streaming\";\"PVS-based oscillator simulator.\";\"fsig pvsosc kamp, kfreq, ktype, isize [,ioverlap] [, iwinsize] [, iwintype] [, iformat]\"",
        "\"pvsout\";\"Spectral Processing:Streaming\";\"Write a fsig to the pvs output bus.\";\"pvsout fsig, kchan\"",
        "\"pvspitch\";\"Spectral Processing:Streaming\";\"Track the pitch and amplitude of a PVS signal.\";\"kfr, kamp pvspitch fsig, kthresh\"",
        "\"pvstencil\";\"Spectral Processing:Streaming\";\"Transforms a pvoc stream according to a masking function table.\";\"fsig pvstencil fsigin, kgain, klevel, iftable\"",
        "\"pvsvoc\";\"Spectral Processing:Streaming\";\"Combine the spectral envelope of one fsig with the excitation (frequencies) of another.\";\"fsig pvsvoc famp, fexc, kdepth, kgain [,kcoefs]\"",
        "\"pvswarp\";\"Spectral Processing:Streaming\";\"Warp the spectral envelope of a PVS signal\";\"fsig pvswarp fsigin, kscal, kshift[, klowest, kmeth, kgain, kcoefs]\"",
        "\"pvsynth\";\"Spectral Processing:Streaming\";\"Resynthesise using a FFT overlap-add.\";\"ares pvsynth fsrc, [iinit]\"",
        "\"resyn\";\"Spectral Processing:Streaming\";\"Streaming partial track additive synthesis with cubic phase interpolation with pitch control and support for timescale-modified input\";\"asig resyn fin, kscal, kpitch, kmaxtracks, ifn\"",
        "\"sinsyn\";\"Spectral Processing:Streaming\";\"Streaming partial track additive synthesis with cubic phase interpolation\";\"asig sinsyn fin, kscal, kmaxtracks, ifn\"",
        "\"tab2pvs\";\"Spectral Processing:Streaming\";\"Copies spectral data from t-variables.\";\"fsig tab2pvs tvar[,ihopsize, iwinsize, iwintype]\"",
        "\"tradsyn\";\"Spectral Processing:Streaming\";\"Streaming partial track additive synthesis\";\"asig tradsyn fin, kscal, kpitch, kmaxtracks, ifn\"",
        "\"trcross\";\"Spectral Processing:Streaming\";\"Streaming partial track cross-synthesis.\";\"fsig trcross fin1, fin2, ksearch, kdepth [, kmode]\"",
        "\"trfilter\";\"Spectral Processing:Streaming\";\"Streaming partial track filtering.\";\"fsig trfilter fin, kamnt, ifn\"",
        "\"trhighest\";\"Spectral Processing:Streaming\";\"Extracts the highest-frequency track from a streaming track input signal.\";\"fsig, kfr, kamp trhighest fin1, kscal\"",
        "\"trlowest\";\"Spectral Processing:Streaming\";\"Extracts the lowest-frequency track from a streaming track input signal.\";\"fsig, kfr, kamp trlowest fin1, kscal\"",
        "\"trmix\";\"Spectral Processing:Streaming\";\"Streaming partial track mixing.\";\"fsig trmix fin1, fin2\"",
        "\"trscale\";\"Spectral Processing:Streaming\";\"Streaming partial track frequency scaling.\";\"fsig trscale fin, kpitch[, kgain]\"",
        "\"trshift\";\"Spectral Processing:Streaming\";\"Streaming partial track frequency scaling.\";\"fsig trshift fin, kpshift[, kgain]\"",
        "\"trsplit\";\"Spectral Processing:Streaming\";\"Streaming partial track frequency splitting.\";\"fsiglow, fsighi trsplit fin, ksplit[, kgainlow, kgainhigh]\"",
        "\"ATSadd\";\"Spectral Processing:ATS\";\"uses the data from an ATS analysis file to perform additive synthesis.\";\"ar ATSadd ktimepnt, kfmod, iatsfile, ifn, ipartials[, ipartialoffset,  ipartialincr, igatefn]\"",
        "\"ATSaddnz\";\"Spectral Processing:ATS\";\"uses the data from an ATS analysis file to perform noise resynthesis.\";\"ar ATSaddnz ktimepnt, iatsfile, ibands[, ibandoffset, ibandincr]\"",
        "\"ATSbufread\";\"Spectral Processing:ATS\";\"reads data from and ATS data file and stores it in an internal data table of frequency, amplitude pairs.\";\"ATSbufread ktimepnt, kfmod, iatsfile, ipartials[, ipartialoffset,  ipartialincr]\"",
        "\"ATScross\";\"Spectral Processing:ATS\";\"perform cross synthesis from ATS analysis files.\";\"ar ATScross ktimepnt, kfmod, iatsfile, ifn, kmylev, kbuflev, ipartials  [, ipartialoffset, ipartialincr]\"",
        "\"ATSinfo\";\"Spectral Processing:ATS\";\"reads data out of the header of an ATS file.\";\"idata ATSinfo iatsfile, ilocation\"",
        "\"ATSinterpread\";\"Spectral Processing:ATS\";\"allows a user to determine the frequency envelope of any\";\"kamp ATSinterpread kfreq\"",
        "\"ATSpartialtap\";\"Spectral Processing:ATS\";\"returns a frequency, amplitude pair from an\";\"kfrq, kamp ATSpartialtap ipartialnum\"",
        "\"ATSread\";\"Spectral Processing:ATS\";\"reads data from an ATS file.\";\"kfreq, kamp ATSread ktimepnt, iatsfile, ipartial\"",
        "\"ATSreadnz\";\"Spectral Processing:ATS\";\"reads data from an ATS file.\";\"kenergy ATSreadnz ktimepnt, iatsfile, iband\"",
        "\"ATSsinnoi\";\"Spectral Processing:ATS\";\"uses the data from an ATS analysis file to perform resynthesis.\";\"ar ATSsinnoi ktimepnt, ksinlev, knzlev, kfmod, iatsfile, ipartials  [, ipartialoffset, ipartialincr]\"",
        "\"lorismorph\";\"Spectral Processing:Loris\";\"Morphs two stored sets of bandwidth-enhanced partials and stores a new set of partials representing the morphed sound. The morph is performed by linearly interpolating the parameter envelopes (frequency, amplitude, and bandwidth, or noisiness) of the bandwidth-enhanced partials according to control-rate frequency, amplitude, and bandwidth morphing functions.\";\"lorismorph isrcidx, itgtidx, istoreidx, kfreqmorphenv, kampmorphenv, kbwmorphenv\"",
        "\"lorisplay\";\"Spectral Processing:Loris\";\"renders a stored set of bandwidth-enhanced partials using the method of Bandwidth-Enhanced Additive Synthesis implemented in the Loris software, applying control-rate frequency, amplitude, and bandwidth scaling envelopes.\";\"ar lorisplay ireadidx, kfreqenv, kampenv, kbwenv\"",
        "\"lorisread\";\"Spectral Processing:Loris\";\"Imports a set of bandwidth-enhanced partials from a SDIF-format data file, applying control-rate frequency, amplitude, and bandwidth scaling envelopes, and stores the modified partials in memory.\";\"lorisread ktimpnt, ifilcod, istoreidx, kfreqenv, kampenv, kbwenv[, ifadetime]\"",
        "\"strget\";\"Strings:Definition\";\"Set string variable to value from strset table or string p-field\";\"Sdst strget indx\"",
        "\"strset\";\"Strings:Definition\";\"Allows a string to be linked with a numeric value.\";\"strset iarg, istring\"",
        "\"puts\";\"Strings:Manipulation\";\"Print a string constant or variable\";\"puts Sstr, ktrig[, inonl]\"",
        "\"sprintf\";\"Strings:Manipulation\";\"printf-style formatted output to a string variable.\";\"Sdst sprintf Sfmt, xarg1[, xarg2[, ... ]]\"",
        "\"sprintfk\";\"Strings:Manipulation\";\"printf-style formatted output to a string variable at k-rate.\";\"Sdst sprintfk Sfmt, xarg1[, xarg2[, ... ]]\"",
        "\"strcat\";\"Strings:Manipulation\";\"Concatenate strings\";\"Sdst strcat Ssrc1, Ssrc2\"",
        "\"strcatk\";\"Strings:Manipulation\";\"Concatenate strings (k-rate)\";\"Sdst strcatk Ssrc1, Ssrc2\"",
        "\"strcmp\";\"Strings:Manipulation\";\"Compare strings\";\"ires strcmp S1, S2\"",
        "\"strcmpk\";\"Strings:Manipulation\";\"Compare strings\";\"kres strcmpk S1, S2\"",
        "\"strcpy\";\"Strings:Manipulation\";\"Assign value to a string variable\";\"Sdst strcpy Ssrc\"",
        "\"strcpyk\";\"Strings:Manipulation\";\"Assign value to a string variable (k-rate)\";\"Sdst strcpyk Ssrc\"",
        "\"strindex\";\"Strings:Manipulation\";\"Return the position of the first occurence of a string in another string\";\"ipos strindex S1, S2\"",
        "\"strindexk\";\"Strings:Manipulation\";\"Return the position of the first occurence of a string in another string\";\"kpos strindexk S1, S2\"",
        "\"strlen\";\"Strings:Manipulation\";\"Return the length of a string\";\"ilen strlen Sstr\"",
        "\"strlenk\";\"Strings:Manipulation\";\"Return the length of a string\";\"klen strlenk Sstr\"",
        "\"strrindex\";\"Strings:Manipulation\";\"Return the position of the last occurence of a string in another string\";\"ipos strrindex S1, S2\"",
        "\"strrindexk\";\"Strings:Manipulation\";\"Return the position of the last occurence of a string in another string\";\"kpos strrindexk S1, S2\"",
        "\"strsub\";\"Strings:Manipulation\";\"Extract a substring\";\"Sdst strsub Ssrc[, istart[, iend]]\"",
        "\"strsubk\";\"Strings:Manipulation\";\"Extract a substring\";\"Sdst strsubk Ssrc, kstart, kend\"",
        "\"strchar\";\"Strings:Conversion\";\"Return the ASCII code of a character in a string\";\"ichr strchar Sstr[, ipos]\"",
        "\"strchark\";\"Strings:Conversion\";\"Return the ASCII code of a character in a string\";\"kchr strchark Sstr[, kpos]\"",
        "\"strlower\";\"Strings:Conversion\";\"Convert a string to lower case\";\"Sdst strlower Ssrc\"",
        "\"strlowerk\";\"Strings:Conversion\";\"Convert a string to lower case\";\"Sdst strlowerk Ssrc\"",
        "\"strtod\";\"Strings:Conversion\";\"Converts a string to a float (i-rate).\";\"ir strtod Sstr\"",
        "\"strtodk\";\"Strings:Conversion\";\"Converts a string to a float (k-rate).\";\"kr strtodk Sstr\"",
        "\"strtol\";\"Strings:Conversion\";\"Converts a string to a signed integer (i-rate).\";\"ir strtol Sstr\"",
        "\"strtolk\";\"Strings:Conversion\";\"Converts a string to a signed integer (k-rate).\";\"kr strtolk Sstr\"",
        "\"strupper\";\"Strings:Conversion\";\"Convert a string to upper case\";\"Sdst strupper Ssrc\"",
        "\"strupperk\";\"Strings:Conversion\";\"Convert a string to upper case\";\"Sdst strupperk Ssrc\"",
        "\"vtaba\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtaba andx, ifn, aout1 [, aout2, aout3, .... , aoutN ]\"",
        "\"vtabi\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtabi indx, ifn, iout1 [, iout2, iout3, .... , ioutN ]\"",
        "\"vtabk\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtabk kndx, ifn, kout1 [, kout2, kout3, .... , koutN ]\"",
        "\"vtable1k\";\"Vectorial:Tables\";\"Read a vector (several scalars simultaneously) from a table.\";\"vtable1k kfn,kout1 [, kout2, kout3, .... , koutN ]\"",
        "\"vtablea\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtablea andx, kfn, kinterp, ixmode, aout1 [, aout2, aout3, .... , aoutN ]\"",
        "\"vtablei\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtablei indx, ifn, interp, ixmode, iout1 [, iout2, iout3, .... , ioutN ]\"",
        "\"vtablek\";\"Vectorial:Tables\";\"Read vectors (from tables -or arrays of vectors).\";\"vtablek kndx, kfn, kinterp, ixmode, kout1 [, kout2, kout3, .... , koutN ]\"",
        "\"vtablewa\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtablewa andx, kfn, ixmode, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ]\"",
        "\"vtablewi\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtablewi indx, ifn, ixmode, inarg1 [, inarg2, inarg3 , .... , inargN ]\"",
        "\"vtablewk\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtablewk kndx, kfn, ixmode, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ]\"",
        "\"vtabwa\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtabwa andx, ifn, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ]\"",
        "\"vtabwi\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtabwi indx, ifn, inarg1 [, inarg2, inarg3 , .... , inargN ]\"",
        "\"vtabwk\";\"Vectorial:Tables\";\"Write vectors (to tables -or arrays of vectors).\";\"vtabwk kndx, ifn, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ]\"",
        "\"vadd\";\"Vectorial:Scalar operations\";\"Adds a scalar value to a vector in a table.\";\"vadd ifn, kval, kelements [, kdstoffset] [, kverbose]\"",
        "\"vadd_i\";\"Vectorial:Scalar operations\";\"Adds a scalar value to a vector in a table.\";\"vadd_i ifn, ival, ielements [, idstoffset]\"",
        "\"vexp\";\"Vectorial:Scalar operations\";\"Performs power-of operations between a vector and a scalar\";\"vexp ifn, kval, kelements [, kdstoffset] [, kverbose]\"",
        "\"vexp_i\";\"Vectorial:Scalar operations\";\"Performs power-of operations between a vector and a scalar\";\"vexp_i ifn, ival, ielements[, idstoffset]\"",
        "\"vmult\";\"Vectorial:Scalar operations\";\"Multiplies a vector in a table by a scalar value.\";\"vmult ifn, kval, kelements [, kdstoffset] [, kverbose]\"",
        "\"vmult_i\";\"Vectorial:Scalar operations\";\"Multiplies a vector in a table by a scalar value.\";\"vmult_i ifn, ival, ielements [, idstoffset]\"",
        "\"vpow\";\"Vectorial:Scalar operations\";\"Raises each element of a vector to a scalar power.\";\"vpow ifn, kval, kelements [, kdstoffset] [, kverbose]\"",
        "\"vpow_i\";\"Vectorial:Scalar operations\";\"Raises each element of a vector to a scalar power\";\"vpow_i ifn, ival, ielements [, idstoffset]\"",
        "\"vaddv\";\"Vectorial:Vectorial operations\";\"Performs addition between two vectorial control signals.\";\"vaddv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vaddv_i\";\"Vectorial:Vectorial operations\";\"Performs addition between two vectorial control signals at init time.\";\"vaddv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vcopy\";\"Vectorial:Vectorial operations\";\"Copies between two vectorial control signals\";\"vcopy ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [, kverbose]\"",
        "\"vcopy_i\";\"Vectorial:Vectorial operations\";\"Copies a vector from one table to another.\";\"vcopy_i ifn1, ifn2, ielements [,idstoffset, isrcoffset]\"",
        "\"vdivv\";\"Vectorial:Vectorial operations\";\"Performs division between two vectorial control signals\";\"vdivv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vdivv_i\";\"Vectorial:Vectorial operations\";\"Performs division between two vectorial control signals at init time.\";\"vdivv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vexpv\";\"Vectorial:Vectorial operations\";\"Performs exponential operations between two vectorial control signals\";\"vexpv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vexpv_i\";\"Vectorial:Vectorial operations\";\"Performs exponential operations between two vectorial control signals at init time.\";\"vexpv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vmap\";\"Vectorial:Vectorial operations\";\"Maps elements from a vector according to indexes contained in another vector.\";\"vmap ifn1, ifn2, ielements [,idstoffset, isrcoffset]\"",
        "\"vmultv\";\"Vectorial:Vectorial operations\";\"Performs mutiplication between two vectorial control signals\";\"vmultv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vmultv_i\";\"Vectorial:Vectorial operations\";\"Performs mutiplication between two vectorial control signals at init time.\";\"vmultv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vpowv\";\"Vectorial:Vectorial operations\";\"Performs power-of operations between two vectorial control signals\";\"vpowv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vpowv_i\";\"Vectorial:Vectorial operations\";\"Performs power-of operations between two vectorial control signals at init time.\";\"vpowv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vsubv\";\"Vectorial:Vectorial operations\";\"Performs subtraction between two vectorial control signals\";\"vsubv ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]\"",
        "\"vsubv_i\";\"Vectorial:Vectorial operations\";\"Performs subtraction between two vectorial control signals at init time.\";\"vsubv_i ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]\"",
        "\"vexpseg\";\"Vectorial:Envelopes\";\"Vectorial envelope generator\";\"vexpseg ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]]\"",
        "\"vlinseg\";\"Vectorial:Envelopes\";\"Vectorial envelope generator\";\"vlinseg ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]]\"",
        "\"vlimit\";\"Vectorial:Limiting and Wrapping\";\"Limiting and Wrapping Vectorial Signals\";\"vlimit ifn, kmin, kmax, ielements\"",
        "\"vmirror\";\"Vectorial:Limiting and Wrapping\";\"Limiting and Wrapping Vectorial Signals\";\"vmirror ifn, kmin, kmax, ielements\"",
        "\"vwrap\";\"Vectorial:Limiting and Wrapping\";\"Limiting and Wrapping Vectorial Signals\";\"vwrap ifn, kmin, kmax, ielements\"",
        "\"vdelayk\";\"Vectorial:Delay Paths\";\"k-rate variable time delay.\";\"kout vdelayk iksig, kdel, imaxdel [, iskip, imode]\"",
        "\"vecdelay\";\"Vectorial:Delay Paths\";\"Vectorial Control-rate Delay Paths\";\"vecdelay ifn, ifnIn, ifnDel, ielements, imaxdel [, iskip]\"",
        "\"vport\";\"Vectorial:Delay Paths\";\"Vectorial Control-rate Delay Paths\";\"vport ifn, khtime, ielements [, ifnInit]\"",
        "\"vrandh\";\"Vectorial:Random\";\"Generates a vector of random numbers stored into a table, holding the values for a period of time.\";\"vrandh ifn, krange, kcps, ielements [, idstoffset] [, iseed]  [, isize] [, ioffset]\"",
        "\"vrandi\";\"Vectorial:Random\";\"Generate a sort of 'vectorial band-limited noise'\";\"vrandi ifn, krange, kcps, ielements [, idstoffset] [, iseed]  [, isize] [, ioffset]\"",
        "\"cell\";\"Vectorial:Cellular Automata\";\"Cellular Automaton\";\"cell ktrig, kreinit, ioutFunc, initStateFunc, iRuleFunc, ielements\"",
        "\"vcella\";\"Vectorial:Cellular Automata\";\"Cellular Automata\";\"vcella ktrig, kreinit, ioutFunc, initStateFunc,  iRuleFunc, ielements, irulelen [, iradius]\"",
        "\"zacl\";\"Zak Patch System\";\"Clears one or more variables in the za space.\";\"zacl kfirst, klast\"",
        "\"zakinit\";\"Zak Patch System\";\"Establishes zak space.\";\"zakinit isizea, isizek\"",
        "\"zamod\";\"Zak Patch System\";\"Modulates one a-rate signal by a second one.\";\"ares zamod asig, kzamod\"",
        "\"zar\";\"Zak Patch System\";\"Reads from a location in za space at a-rate.\";\"ares zar kndx\"",
        "\"zarg\";\"Zak Patch System\";\"Reads from a location in za space at a-rate, adds some gain.\";\"ares zarg kndx, kgain\"",
        "\"zaw\";\"Zak Patch System\";\"Writes to a za variable at a-rate without mixing.\";\"zaw asig, kndx\"",
        "\"zawm\";\"Zak Patch System\";\"Writes to a za variable at a-rate with mixing.\";\"zawm asig, kndx [, imix]\"",
        "\"zir\";\"Zak Patch System\";\"Reads from a location in zk space at i-rate.\";\"ir zir indx\"",
        "\"ziw\";\"Zak Patch System\";\"Writes to a zk variable at i-rate without mixing.\";\"ziw isig, indx\"",
        "\"ziwm\";\"Zak Patch System\";\"Writes to a zk variable to an i-rate variable with mixing.\";\"ziwm isig, indx [, imix]\"",
        "\"zkcl\";\"Zak Patch System\";\"Clears one or more variables in the zk space.\";\"zkcl kfirst, klast\"",
        "\"zkmod\";\"Zak Patch System\";\"Facilitates the modulation of one signal by another.\";\"kres zkmod ksig, kzkmod\"",
        "\"zkr\";\"Zak Patch System\";\"Reads from a location in zk space at k-rate.\";\"kres zkr kndx\"",
        "\"zkw\";\"Zak Patch System\";\"Writes to a zk variable at k-rate without mixing.\";\"zkw ksig, kndx\"",
        "\"zkwm\";\"Zak Patch System\";\"Writes to a zk variable at k-rate with mixing.\";\"zkwm ksig, kndx [, imix]\"",
        "\"dssiactivate\";\"Plugin Hosting:DSSI and LADSPA\";\"Activates or deactivates a DSSI or LADSPA plugin.\";\"dssiactivate ihandle, ktoggle\"",
        "\"dssiaudio\";\"Plugin Hosting:DSSI and LADSPA\";\"Processes audio using a LADSPA or DSSI plugin.\";\"[aout1, aout2, ..., aout9] dssiaudio ihandle, [ain1, ain2, ..., ain9]\"",
        "\"dssictls\";\"Plugin Hosting:DSSI and LADSPA\";\"Send control information to a LADSPA or DSSI plugin.\";\"dssictls ihandle, iport, kvalue, ktrigger\"",
        "\"dssiinit\";\"Plugin Hosting:DSSI and LADSPA\";\"Loads a DSSI or LADSPA plugin.\";\"ihandle dssiinit ilibraryname, iplugindex [, iverbose]\"",
        "\"dssilist\";\"Plugin Hosting:DSSI and LADSPA\";\"Lists all available DSSI and LADSPA plugins.\";\"dssilist\"",
        "\"vstaudio\";\"Plugin Hosting:VST\";\"VST audio output.\";\"aout1,aout2 vstaudio instance, [ain1, ain2]\"",
        "\"vstaudiog\";\"Plugin Hosting:VST\";\"VST audio output.\";\"aout1,aout2 vstaudiog instance, [ain1, ain2]\"",
        "\"vstbankload\";\"Plugin Hosting:VST\";\"Loads parameter banks to a VST plugin.\";\"vstbankload instance, ipath\"",
        "\"vstedit\";\"Plugin Hosting:VST\";\"Opens the GUI editor window for a VST plugin.\";\"vstedit instance\"",
        "\"vstinfo\";\"Plugin Hosting:VST\";\"Displays the parameters and the programs of a VST plugin.\";\"vstinfo instance\"",
        "\"vstinit\";\"Plugin Hosting:VST\";\"Load a VST plugin into memory for use with the other vst4cs opcodes.\";\"instance vstinit ilibrarypath [,iverbose]\"",
        "\"vstmidiout\";\"Plugin Hosting:VST\";\"Sends MIDI information to a VST plugin.\";\"vstmidiout instance, kstatus, kchan, kdata1, kdata2\"",
        "\"vstnote\";\"Plugin Hosting:VST\";\"Sends a MIDI note with definite duration to a VST plugin.\";\"vstnote instance, kchan, knote, kveloc, kdur\"",
        "\"vstparamset \";\"Plugin Hosting:VST\";\"Used for parameter comunication to and from a VST plugin.\";\"vstparamset instance, kparam, kvalue\"",
        "\"vstparamget \";\"Plugin Hosting:VST\";\"Used for parameter comunication to and from a VST plugin.\";\"kvalue vstparamget instance, kparam\"",
        "\"vstprogset\";\"Plugin Hosting:VST\";\"Loads parameter banks to a VST plugin.\";\"vstprogset instance, kprogram\"",
        "\"OSCinit\";\"OSC\";\"Start a listening process for OSC messages to a particular port.\";\"ihandle OSCinit iport\"",
        "\"OSClisten\";\"OSC\";\"Listen for OSC messages to a particular path.\";\"kans OSClisten ihandle, idest, itype [, xdata1, xdata2, ...]\"",
        "\"OSCsend\";\"OSC\";\"Sends data to other processes using the OSC protocol\";\"OSCsend kwhen, ihost, iport, idestination, itype [, kdata1, kdata2, ...]\"",
        "\"remoteport\";\"Network\";\"Defines the port for use with the remote system.\";\"remoteport iportnum\"",
        "\"sockrecv\";\"Network\";\"Receives data from other processes using the low-level UDP or TCP protocols\";\"asig sockrecv iport, ilength\"",
        "\"sockrecvs\";\"Network\";\"Receives data from other processes using the low-level UDP or TCP protocols\";\"asigl, asigr sockrecvs iport, ilength\"",
        "\"strecv\";\"Network\";\"Receives data from other processes using the low-level UDP or TCP protocols\";\"asig strecv Sipaddr, iport\"",
        "\"socksend\";\"Network\";\"Sends data to other processes using the low-level UDP or TCP protocols\";\"socksend asig, Sipaddr, iport, ilength\"",
        "\"socksends\";\"Network\";\"Sends data to other processes using the low-level UDP or TCP protocols\";\"socksends asigl, asigr, Sipaddr, iport, ilength\"",
        "\"stsend\";\"Network\";\"Sends data to other processes using the low-level UDP or TCP protocols\";\"stsend asig, Sipaddr, iport\"",
        "\"insglobal\";\"Remote Opcodes\";\"An opcode which can be used to implement a remote orchestra. This opcode will send note events from a source machine to many destinations.\";\"insglobal isource, instrnum [,instrnum...]\"",
        "\"insremot\";\"Remote Opcodes\";\"An opcode which can be used to implement a remote orchestra. This opcode will send note events from a source machine to one destination.\";\"insremot idestination, isource, instrnum [,instrnum...]\"",
        "\"midglobal\";\"Remote Opcodes\";\"An opcode which can be used to implement a remote midi orchestra. This opcode will broadcast the midi events to all the machines involved in the remote concert.\";\"midglobal isource, instrnum [,instrnum...]\"",
        "\"midremot\";\"Remote Opcodes\";\"An opcode which can be used to implement a remote midi orchestra. This opcode will send midi events from a source machine to one destination.\";\"midremot idestination, isource, instrnum [,instrnum...]\"",
        "\"MixerClear\";\"Mixer Opcodes\";\"Resets all channels of a buss to 0.\";\"MixerClear\"",
        "\"MixerGetLevel\";\"Mixer Opcodes\";\"Gets the level of a send to a buss.\";\"kgain MixerGetLevel isend, ibuss\"",
        "\"MixerReceive\";\"Mixer Opcodes\";\"Receives an arate signal from a channel of a buss.\";\"asignal MixerReceive ibuss, ichannel\"",
        "\"MixerSend\";\"Mixer Opcodes\";\"Mixes an arate signal into a channel of a buss.\";\"MixerSend asignal, isend, ibuss, ichannel\"",
        "\"MixerSetLevel\";\"Mixer Opcodes\";\"Sets the level of a send to a buss.\";\"MixerSetLevel isend, ibuss, kgain\"",
        "\"MixerSetLevel_i\";\"Mixer Opcodes\";\"Sets the level of a send to a buss.\";\"MixerSetLevel_i isend, ibuss, igain\"",
        "\"pyassign\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pyassign \"variable\", kvalue\"",
        "\"pyassigni\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pyassigni \"variable\", ivalue\"",
        "\"pylassign\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pylassign \"variable\", kvalue\"",
        "\"pylassigni\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pylassigni \"variable\", ivalue\"",
        "\"pyassignt\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pyassignt ktrigger, \"variable\", kvalue\"",
        "\"pylassignt\";\"Python Opcodes\";\"Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.\";\"pylassignt ktrigger, \"variable\", kvalue\"",
        "\"pycall\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pycall \"callable\", karg1, ...\"",
        "\"pycall1\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult pycall1 \"callable\", karg1, ...\"",
        "\"pycall2\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult1, kresult2 pycall2 \"callable\", karg1, ...\"",
        "\"pycall3\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3 pycall3 \"callable\", karg1, ...\"",
        "\"pycall4\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4 pycall4 \"callable\", karg1, ...\"",
        "\"pycall5\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5 pycall5 \"callable\", karg1, ...\"",
        "\"pycall6\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6 pycall6 \"callable\", karg1, ...\"",
        "\"pycall7\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7 pycall7 \"callable\", karg1, ...\"",
        "\"pycall8\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 pycall8 \"callable\", karg1, ...\"",
        "\"pycallt\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pycallt ktrigger, \"callable\", karg1, ...\"",
        "\"pycall1t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult pycall1t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall2t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult1, kresult2 pycall2t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall3t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3 pycall3t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall4t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4 pycall4t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall5t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5 pycall5t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall6t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6 pycall6t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall7t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7 pycall7t ktrigger, \"callable\", karg1, ...\"",
        "\"pycall8t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 pycall8t ktrigger, \"callable\", karg1, ...\"",
        "\"pycalli\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pycalli \"callable\", karg1, ...\"",
        "\"pycall1i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"iresult pycall1i \"callable\", iarg1, ...\"",
        "\"pycall2i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"iresult1, iresult2 pycall2i \"callable\", iarg1, ...\"",
        "\"pycall3i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3 pycall3i \"callable\", iarg1, ...\"",
        "\"pycall4i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4 pycall4i \"callable\", iarg1, ...\"",
        "\"pycall5i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5 pycall5i \"callable\", iarg1, ...\"",
        "\"pycall6i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6 pycall6i \"callable\", iarg1, ...\"",
        "\"pycall7i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6, ir7 pycall7i \"callable\", iarg1, ...\"",
        "\"pycall8i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8 pycall8i \"callable\", iarg1, ...\"",
        "\"pycalln\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pycalln \"callable\", nresults, kresult1, ..., kresultn, karg1, ...\"",
        "\"pycallni\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pycallni \"callable\", nresults, iresult1, ..., iresultn, iarg1, ...\"",
        "\"pylcall\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pylcall \"callable\", karg1, ...\"",
        "\"pylcall1\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult pylcall1 \"callable\", karg1, ...\"",
        "\"pylcall2\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult1, kresult2 pylcall2 \"callable\", karg1, ...\"",
        "\"pylcall3\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3 pylcall3 \"callable\", karg1, ...\"",
        "\"pylcall4\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4 pylcall4 \"callable\", karg1, ...\"",
        "\"pylcall5\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5 pylcall5 \"callable\", karg1, ...\"",
        "\"pylcall6\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6 pylcall6 \"callable\", karg1, ...\"",
        "\"pylcall7\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7 pylcall7 \"callable\", karg1, ...\"",
        "\"pylcall8\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 pylcall8 \"callable\", karg1, ...\"",
        "\"pylcallt\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pylcallt ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall1t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult pylcall1t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall2t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kresult1, kresult2 pylcall2t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall3t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3 pylcall3t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall4t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4 pylcall4t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall5t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5 pylcall5t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall6t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6 pylcall6t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall7t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7 pylcall7t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcall8t\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 pylcall8t ktrigger, \"callable\", karg1, ...\"",
        "\"pylcalli\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pylcalli \"callable\", karg1, ...\"",
        "\"pylcall1i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"iresult pylcall1i \"callable\", iarg1, ...\"",
        "\"pylcall2i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"iresult1, iresult2 pylcall2i \"callable\", iarg1, ...\"",
        "\"pylcall3i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3 pylcall3i \"callable\", iarg1, ...\"",
        "\"pylcall4i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4 pylcall4i \"callable\", iarg1, ...\"",
        "\"pylcall5i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5 pylcall5i \"callable\", iarg1, ...\"",
        "\"pylcall6i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6 pylcall6i \"callable\", iarg1, ...\"",
        "\"pylcall7i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6, ir7 pylcall7i \"callable\", iarg1, ...\"",
        "\"pylcall8i\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8 pylcall8i \"callable\", iarg1, ...\"",
        "\"pylcalln\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pylcalln \"callable\", nresults, kresult1, ..., kresultn, karg1, ...\"",
        "\"pylcallni\";\"Python Opcodes\";\"Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.\";\"pylcallni \"callable\", nresults, iresult1, ..., iresultn, iarg1, ...\"",
        "\"pyeval\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"kresult pyeval \"expression\"\"",
        "\"pyevali\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"iresult pyevali \"expression\"\"",
        "\"pyleval\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"kresult pyleval \"expression\"\"",
        "\"pylevali\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"iresult pylevali \"expression\"\"",
        "\"pyevalt\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"kresult pyevalt ktrigger, \"expression\"\"",
        "\"pylevalt\";\"Python Opcodes\";\"Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).\";\"kresult pylevalt ktrigger, \"expression\"\"",
        "\"pyexec\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"pyexec \"filename\"\"",
        "\"pyexeci\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"pyexeci \"filename\"\"",
        "\"pylexec\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"pylexec \"filename\"\"",
        "\"pylexeci\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"pylexeci \"filename\"\"",
        "\"pyexect\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"pyexect ktrigger, \"filename\"\"",
        "\"plyexect\";\"Python Opcodes\";\"Execute a script from a file at k-time or i-time (i suffix).\";\"plyexect ktrigger, \"filename\"\"",
        "\"pyinit\";\"Python Opcodes\";\"Initialize the Python interpreter.\";\"pyinit\"",
        "\"pyrun\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pyrun \"statement\"\"",
        "\"pyruni\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pyruni \"statement\"\"",
        "\"pylrun\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pylrun \"statement\"\"",
        "\"pylruni\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pylruni \"statement\"\"",
        "\"pyrunt\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pyrunt ktrigger, \"statement\"\"",
        "\"pylrunt\";\"Python Opcodes\";\"Run a Python statement or block of statements.\";\"pylrunt ktrigger, \"statement\"\"",
        "\"imagecreate\";\"Image Processing Opcodes\";\"Create an empty image of a given size.\";\"iimagenum imagecreate iwidth, iheight\"",
        "\"imagefree\";\"Image Processing Opcodes\";\"Frees memory allocated for a previously loaded or created image.\";\"imagefree iimagenum\"",
        "\"imagegetpixel\";\"Image Processing Opcodes\";\"Return the RGB pixel values of a previously opened or created image.\";\"ared, agreen, ablue imagegetpixel iimagenum, ax, ay\"",
        "\"imageload\";\"Image Processing Opcodes\";\"Load an image.\";\"iimagenum imageload filename\"",
        "\"imagesave\";\"Image Processing Opcodes\";\"Save a previously created image.\";\"imagesave iimagenum, filename\"",
        "\"imagesetpixel\";\"Image Processing Opcodes\";\"Set the RGB value of a pixel inside a previously opened or created image.\";\"imagesetpixel iimagenum, ax, ay, ared, agreen, ablue\"",
        "\"imagesize\";\"Image Processing Opcodes\";\"Return the width and height of a previously opened or created image.\";\"iwidth, iheight imagesize iimagenum\"",
        "\"fareylen\";\"Miscellaneous\";\"returns the length of a Farey Sequence.\";\"kfl fareylen kfn\"",
        "\"fareyleni\";\"Miscellaneous\";\"returns the length of a Farey Sequence.\";\"ifl fareyleni ifn\"",
        "\"modmatrix\";\"Miscellaneous\";\"Modulation matrix opcode with optimizations for sparse matrices.\";\"modmatrix iresfn, isrcmodfn, isrcparmfn, imodscale, inum_mod,  inum_parm, kupdate\"",
        "\"system_i\";\"Miscellaneous\";\"Call an external program via the system call\";\"ires system_i itrig, Scmd, [inowait]\"",
        "\"system\";\"Miscellaneous\";\"Call an external program via the system call\";\"kres system ktrig, Scmd, [knowait]\"",
        "\"tableshuffle\";\"Miscellaneous\";\"shuffles the content of a function table so that each element of the source table is put into a different random position.\";\"tableshuffle ktablenum\"",
        "\"tableshufflei\";\"Miscellaneous\";\"shuffles the content of a function table so that each element of the source table is put into a different random position.\";\"tableshufflei itablenum\"",
        "\"bmopen\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmoscil\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmoscili\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmscan\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmscani\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmtable\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"bmtablei\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"call\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"calld\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"callm\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"callmd\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsCommitDeferredSettings\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsCommitDeferredSettings_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeAngles\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeAngles_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeOrientation\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeOrientation_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeOutsideVolume\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsConeOutsideVolume_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsEaxSetDeferredFlag\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerDistanceFactor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerDistanceFactor_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerOrientation\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerOrientation_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerPosition\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerPosition_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerRolloffFactor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerRolloffFactor_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerSetAll\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsListenerSetAll_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMaxDistance\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMaxDistance_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMinDistance\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMinDistance_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMode\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsMode_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsPosition\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsPosition_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsSetAll\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"DsSetAll_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerAirAbsorption\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerAirAbsorption_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerAll\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerAll_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerDecayTime\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerDecayTime_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerDecayTimeHfRatio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerDecayTimeHfRatio_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvDiffusion\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvDiffusion_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvironment\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvironment_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvSize\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerEnvSize_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerFlags\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerFlags_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReflections\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReflections_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReflectionsDelay\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReflectionsDelay_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReverb\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReverb_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReverbDelay\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerReverbDelay_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoom\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoom_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoomHF\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoomHF_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoomRolloff\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxListenerRoomRolloff_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceAirAbsorption\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceAirAbsorption_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxsourceAll\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceAll_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceDirect\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceDirect_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceDirectHF\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceDirectHF_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceFlags\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceFlags_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceObstruction\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceObstruction_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceObstructionRatio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceObstructionRatio_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusion\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusion_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusionRatio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusionRatio_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusionRoomRatio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOcclusionRoomRatio_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOutsideVolumeHF\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceOutsideVolumeHF_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoom\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoom_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoomHF\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoomHF_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoomRolloff\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"EaxSourceRoomRolloff_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"Flbox\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLgroup_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLpack_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLpanel_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLscroll_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLsetImage\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLsetOverlay\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLtabs_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLtextSize\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"fof3\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"foscili2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"ftlen2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GL3dStudioModel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLabs\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLacos\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glArrayElement\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLasin\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLatan\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glBegin\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glBindTexture\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLbirnd\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glBlendFunc\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glCallList\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glClear\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glClearColor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLclearwhen\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glClipPlane\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glColor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glColor3\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glColorPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLcos\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLcosh\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glCullFace\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glDisable\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glDisableClientState\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLdiv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glDrawArrays\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glDrawBuffer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glDrawElements\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEdgeFlagPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLelse\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEnable\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEnableClientState\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEnd\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLend_for\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLend_if\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEndList\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEvalCoord1\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEvalCoord2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEvalMesh1\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glEvalMesh2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLexp\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLfont3d\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLfor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLfps\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLfrac\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glFrontFace\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glFrustum\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLfullscreen\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glHint\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLif\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glIndexPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLinsert\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLinsert_i\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLint\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLight\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLightModel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLightModelv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLightv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLineWidth\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLoadIdentity\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLoadMatrix\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glLoadMatrixv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLloadPicasso\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLloadTexture\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLlog\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLlog10\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMap1\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMap2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMapGrid1\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMapGrid2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMaterial\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMatrixMode\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLmetro\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLmod\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLmul\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMultMatrix\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glMultMatrixv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glNewList\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glNormal3\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glNormalPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLopenVideoFile\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glOrtho\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLoscil\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLoscili\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLpanel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLpanel_end\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLphasor\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glPixelMap\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glPixelTransfer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glPopMatrix\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glPushMatrix\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLratio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLredraw\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLrender3dStudioModel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLrenderPicasso\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLrnd\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glRotate\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glScale\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glShadeModel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLshininess\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLsin\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLsinh\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLsqr\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLsub\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLsum\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtab\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtabw\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtan\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtanh\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtexCircle\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexCoord2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexCoordPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtexCube\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexEnvfv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexEnvi\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexGenfv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTexGeni\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtexSquare\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLtext3d\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glTranslate\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluBeginCurve\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluBeginSurface\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluBeginTrim\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluCylinder\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluDisk\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluEndCurve\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluEndSurface\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluEndTrim\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluLookAt\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluNewNurbsRenderer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluNewQuadric\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluNurbsCurve\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluNurbsProperty\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluNurbsSurface\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluPerspective\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluPwlCurve\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluQuadricDrawStyle\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluQuadricNormals\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluQuadricTexture\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluSphere\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutCube\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutDodecahedron\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessBeginContour\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessBeginPolygon\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessEndContour\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessEndPolygon\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessVertex\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"gluTessVertexv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutIcosahedron\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutOctahedron\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutSphere\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutTetrahedron\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glutTorus\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvadd\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvaddv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvcopy\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvdivv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glVertex3\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"glVertexPointer\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvexp\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvexpv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvideo2tex\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvideoCapture\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvlimit\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvmap\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvmirror\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvmult\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvmultv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvphaseseg\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvpow\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvpowv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvsubv\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvtab\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvtabw\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLvwrap\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLwaitInitStage\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"GLwavefrontModel\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"img2GLtex\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"imgConvolve\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"imgCreate\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"imgGain\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"imgPoint\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"Init3dAudio\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"InitEAX\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"loscil2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"lposcint\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"lposcinta\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"lposcintsa\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"lposcintsa2\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"marimjpff\";\"CSoundAV Opcodes\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"add\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"and\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"cogoto\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"connect\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"convle\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"ctlchn\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"delayk\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"div\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"ephasor\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLhvsBoxSetValue\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"flooper3\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"FLsetVali\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"inleta\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"inletf\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"inletk\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"inletkid\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_add_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_add_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_add_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_add_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_assign_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_assign_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_assign_t\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_assign_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_assign_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_conjugate_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_conjugate_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_conjugate_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_conjugate_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_distance_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_distance_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_divide_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_divide_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_divide_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_divide_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_mc_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_mr_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_dot_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_get_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_get_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_get_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_get_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_invert_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_invert_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lower_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lower_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_det_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_det_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_factor_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_factor_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_lu_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_mc_create\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_mc_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_mr_create\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_mr_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_multiply_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_multiply_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_multiply_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_multiply_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_euclid_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_euclid_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_euclid_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_euclid_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_inf_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_inf_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_inf_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_inf_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_max_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm_max_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm1_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm1_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm1_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_norm1_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_print_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_print_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_print_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_print_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_eigen_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_eigen_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_factor_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_factor_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_sym_eigen_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_qr_sym_eigen_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_random_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_random_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_random_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_random_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_size_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_size_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_size_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_size_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_subtract_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_subtract_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_subtract_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_subtract_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_t_assign\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_trace_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_trace_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_transpose_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_transpose_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_upper_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_upper_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_vc_create\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_vc_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_vr_create\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_i_vr_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_a_assign\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_add_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_add_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_add_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_add_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_a\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_f\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_t\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_assign_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_conjugate_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_conjugate_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_conjugate_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_conjugate_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_current_f\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_current_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_distance_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_distance_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_divide_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_divide_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_divide_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_divide_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_mc_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_mr_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_dot_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_f_assign\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_get_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_get_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_get_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_get_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_invert_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_invert_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lower_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lower_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_det_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_det_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_factor_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_factor_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_lu_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_mc_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_mr_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_multiply_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_multiply_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_multiply_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_multiply_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_euclid_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_euclid_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_euclid_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_euclid_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_inf_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_inf_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_inf_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_inf_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_max_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm_max_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm1_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm1_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm1_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_norm1_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_eigen_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_eigen_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_factor_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_factor_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_sym_eigen_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_qr_sym_eigen_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_random_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_random_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_random_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_random_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_subtract_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_subtract_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_subtract_vc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_subtract_vr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_t_assign\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_trace_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_trace_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_upper_solve_mc\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_upper_solve_mr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_vc_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"la_k_vr_set\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"lpform\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"maxk\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"median\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mediank\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"midipgm\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mincer\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mod\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mul\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mutex_lock\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mutex_locki\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mutex_unlock\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"mutex_unlocki\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"nlalp\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"not\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"or\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"OSCrecv\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"outleta\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"outletf\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"outletk\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"outletkid\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"pgmchn\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"pitchac\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"pvsenvftw\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"pvstanal\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"qinf\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"qnan\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"readks\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"setscorepos\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"shl\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"shr\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"sub\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"tablefilter\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"tablefilteri\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"tabref\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"temposcal\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"vdel_k\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"xor\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"until\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"enduntil\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"do\";\"Uncategorized\";\"(Description not available)\";\"(Syntax not available)\"",
        "\"cabbageSet\";\"Set a Cabbage widget identifier\";\"Set a Cabbage widget identifier.\";\"cabbageSet kTrig, SChannel, SIdentifier, XArgs   |   cabbageSet kTrig, SChannel, SIdentifierString   |   cabbageSet SChannel, SIdentifierString",
        "\"cabbageGet\";\"Get a Cabbage widget identifier\";\"Get a Cabbage widget identifier.\";\"kVal/kIdent[] [, kTrig] cabbageGet SChannel, SIdentifier   |   SVal/SIdent[] [, kTrig] cabbageGet SChannel, SIdentifier   |   kChannelValue [, kTrig] cabbageGet SChannel   |   SChannelValue [, kTrig] cabbageGet SChannel",
        "\"cabbageGetValue\";\"Gets the value of Cabbage widget\";\"Gets the value of Cabbage widget.\";\"kValue [, kTrig] cabbageGetValue SChannel   |   SValue [, kTrig] cabbageGetValue SChannel   |   cabbageSetValue SChannel, kValue [, kTrig]",
        "\"cabbageSetValue\";\"Sets the value of Cabbage widget\";\"Sets the value of Cabbage widget.\";\"cabbageSetValue SChannel, kValue [, kTrig]",
        "\"cabbageGetWidgetChannels\";\"Gets an array of Cabbage widget channels\";\"Gets an array of Cabbage widget channels\";\"SChannels[] cabbageGetWidgetChannels [SIdentifierFilter]",
        "\"cabbageGetWidgetChannels\";\"Gets an array of Cabbage widget channels\";\"Gets an array of Cabbage widget channels\";\"SChannels[] cabbageGetWidgetChannels [SIdentifierFilter]",
        
        "\"cabbageFindFiles\";\"Gets an array of files from a directory.\";\"Gets an array of files from a directory\";\"SFiles[] cabbageFindFiles SLocation [, SType, SExtension] - SFiles[] cabbageFindFiles kTriggerFind, SLocation [, SType, SExtension]"};
    return opcodes;
}



#endif  // CABBAGESTRINGS_H_INCLUDED
