#include "openmwbindings.hpp"

namespace MWScriptExtensions
{
    extern MWScript::InterpreterContext& context;
    extern Interpreter::Interpreter interpreter;//define these in the startexternalscript opcode and install opcodes

    void activate()
    {
        Interpreter::Type_Code codeword = 3388997749;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void additem(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388997750;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void addsoulgem(std::string arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3388998131;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void addspell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997959;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void addtolevcreature(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3388998395;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void addtolevitem(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3388998397;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void addtopic(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997946;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aiactivate(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3254787584;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aiescort(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Integer arg5)
    {
        Interpreter::Type_Code codeword = 3254780416;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 6;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg5!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aiescortcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5, Interpreter::Type_Integer arg6)
    {
        Interpreter::Type_Code codeword = 3254788096;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 7;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg6!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aifollow(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10, Interpreter::Type_Integer arg11, Interpreter::Type_Integer arg12)
    {
        Interpreter::Type_Code codeword = 3254788608;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 13;
        uint optionalArgCount = 8;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg12!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg12);
            argumentsPassed++;
        }
        if (arg11!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg11);
            argumentsPassed++;
        }
        if (arg10!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg10);
            argumentsPassed++;
        }
        if (arg9!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg9);
            argumentsPassed++;
        }
        if (arg8!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg8);
            argumentsPassed++;
        }
        if (arg7!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg7);
            argumentsPassed++;
        }
        if (arg6!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aifollowcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5, Interpreter::Type_Integer arg6)
    {
        Interpreter::Type_Code codeword = 3254789120;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 7;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg6!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aitravel(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
    {
        Interpreter::Type_Code codeword = 3254779904;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 4;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void aiwander(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3, Interpreter::Type_Integer arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10, Interpreter::Type_Integer arg11, Interpreter::Type_Integer arg12)
    {
        Interpreter::Type_Code codeword = 3254784000;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 13;
        uint optionalArgCount = 10;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg12!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg12);
            argumentsPassed++;
        }
        if (arg11!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg11);
            argumentsPassed++;
        }
        if (arg10!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg10);
            argumentsPassed++;
        }
        if (arg9!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg9);
            argumentsPassed++;
        }
        if (arg8!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg8);
            argumentsPassed++;
        }
        if (arg7!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg7);
            argumentsPassed++;
        }
        if (arg6!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void bc(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998215;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void becomewerewolf()
    {
        Interpreter::Type_Code codeword = 3388998167;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void betacomment(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998215;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void cast(std::string arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3388998183;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer cellchanged()
    {
        Interpreter::Type_Code codeword = 3388997632;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void centeroncell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997670;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void centeronexterior(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388998182;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void changeweather(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388997952;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void choice(std::string arg0, Interpreter::Type_Integer arg1, std::string arg2, Interpreter::Type_Integer arg3, std::string arg4, Interpreter::Type_Integer arg5, std::string arg6, Interpreter::Type_Integer arg7, std::string arg8, Interpreter::Type_Integer arg9, std::string arg10, Interpreter::Type_Integer arg11, std::string arg12, Interpreter::Type_Integer arg13, std::string arg14, Interpreter::Type_Integer arg15, std::string arg16, Interpreter::Type_Integer arg17, std::string arg18, Interpreter::Type_Integer arg19, std::string arg20, Interpreter::Type_Integer arg21, std::string arg22, Interpreter::Type_Integer arg23, std::string arg24, Interpreter::Type_Integer arg25, std::string arg26, Interpreter::Type_Integer arg27, std::string arg28, Interpreter::Type_Integer arg29, std::string arg30, Interpreter::Type_Integer arg31)
    {
        Interpreter::Type_Code codeword = 3254782464;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 32;
        uint optionalArgCount = 32;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg31!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg31);
            argumentsPassed++;
        }
        if (arg30!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg30);
            argumentsPassed++;
        }
        if (arg29!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg29);
            argumentsPassed++;
        }
        if (arg28!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg28);
            argumentsPassed++;
        }
        if (arg27!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg27);
            argumentsPassed++;
        }
        if (arg26!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg26);
            argumentsPassed++;
        }
        if (arg25!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg25);
            argumentsPassed++;
        }
        if (arg24!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg24);
            argumentsPassed++;
        }
        if (arg23!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg23);
            argumentsPassed++;
        }
        if (arg22!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg22);
            argumentsPassed++;
        }
        if (arg21!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg21);
            argumentsPassed++;
        }
        if (arg20!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg20);
            argumentsPassed++;
        }
        if (arg19!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg19);
            argumentsPassed++;
        }
        if (arg18!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg18);
            argumentsPassed++;
        }
        if (arg17!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg17);
            argumentsPassed++;
        }
        if (arg16!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg16);
            argumentsPassed++;
        }
        if (arg15!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg15);
            argumentsPassed++;
        }
        if (arg14!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg14);
            argumentsPassed++;
        }
        if (arg13!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg13);
            argumentsPassed++;
        }
        if (arg12!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg12);
            argumentsPassed++;
        }
        if (arg11!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg11);
            argumentsPassed++;
        }
        if (arg10!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg10);
            argumentsPassed++;
        }
        if (arg9!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg9);
            argumentsPassed++;
        }
        if (arg8!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg8);
            argumentsPassed++;
        }
        if (arg7!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg7);
            argumentsPassed++;
        }
        if (arg6!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void clearforcejump()
    {
        Interpreter::Type_Code codeword = 3388998232;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void clearforcemovejump()
    {
        Interpreter::Type_Code codeword = 3388998236;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void clearforcerun()
    {
        Interpreter::Type_Code codeword = 3388997972;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void clearforcesneak()
    {
        Interpreter::Type_Code codeword = 3388997976;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void clearinfoactor()
    {
        Interpreter::Type_Code codeword = 3388998213;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void coc(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997670;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void coe(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388998182;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disablelevitation()
    {
        Interpreter::Type_Code codeword = 3388998176;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayercontrols()
    {
        Interpreter::Type_Code codeword = 3388997765;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayerfighting()
    {
        Interpreter::Type_Code codeword = 3388997766;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayerjumping()
    {
        Interpreter::Type_Code codeword = 3388997767;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayerlooking()
    {
        Interpreter::Type_Code codeword = 3388997768;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayermagic()
    {
        Interpreter::Type_Code codeword = 3388997769;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableplayerviewswitch()
    {
        Interpreter::Type_Code codeword = 3388997770;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disableteleporting()
    {
        Interpreter::Type_Code codeword = 3388998165;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void disablevanitymode()
    {
        Interpreter::Type_Code codeword = 3388997771;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void dontsaveobject()
    {
        Interpreter::Type_Code codeword = 3388997971;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void drop(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388998136;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void dropsoulgem(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998138;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablebirthmenu()
    {
        Interpreter::Type_Code codeword = 3388997646;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableclassmenu()
    {
        Interpreter::Type_Code codeword = 3388997647;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableinventorymenu()
    {
        Interpreter::Type_Code codeword = 3388997651;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablelevelupmenu()
    {
        Interpreter::Type_Code codeword = 3388997655;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablelevitation()
    {
        Interpreter::Type_Code codeword = 3388998177;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablemagicmenu()
    {
        Interpreter::Type_Code codeword = 3388997652;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablemapmenu()
    {
        Interpreter::Type_Code codeword = 3388997653;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablenamemenu()
    {
        Interpreter::Type_Code codeword = 3388997648;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayercontrols()
    {
        Interpreter::Type_Code codeword = 3388997758;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayerfighting()
    {
        Interpreter::Type_Code codeword = 3388997759;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayerjumping()
    {
        Interpreter::Type_Code codeword = 3388997760;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayerlooking()
    {
        Interpreter::Type_Code codeword = 3388997761;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayermagic()
    {
        Interpreter::Type_Code codeword = 3388997762;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableplayerviewswitch()
    {
        Interpreter::Type_Code codeword = 3388997763;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableracemenu()
    {
        Interpreter::Type_Code codeword = 3388997649;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablerest()
    {
        Interpreter::Type_Code codeword = 3388997655;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablestatreviewmenu()
    {
        Interpreter::Type_Code codeword = 3388997650;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablestatsmenu()
    {
        Interpreter::Type_Code codeword = 3388997654;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enableteleporting()
    {
        Interpreter::Type_Code codeword = 3388998166;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void enablevanitymode()
    {
        Interpreter::Type_Code codeword = 3388997764;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void equip(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998067;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void explodespell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998185;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void face(Interpreter::Type_Integer arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388998220;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void fadein(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997948;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void fadeout(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997949;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void fadeto(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388997950;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void fall()
    {
        Interpreter::Type_Code codeword = 3388998154;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void fillmap()
    {
        Interpreter::Type_Code codeword = 3388998049;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void forcegreeting()
    {
        Interpreter::Type_Code codeword = 3388997967;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void forcejump()
    {
        Interpreter::Type_Code codeword = 3388998234;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void forcemovejump()
    {
        Interpreter::Type_Code codeword = 3388998238;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void forcerun()
    {
        Interpreter::Type_Code codeword = 3388997974;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void forcesneak()
    {
        Interpreter::Type_Code codeword = 3388997978;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer getacrobatics()
    {
        Interpreter::Type_Code codeword = 3388997794;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getagility()
    {
        Interpreter::Type_Code codeword = 3388997674;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getaipackagedone()
    {
        Interpreter::Type_Code codeword = 3388997756;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getalarm()
    {
        Interpreter::Type_Code codeword = 3388998085;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getalchemy()
    {
        Interpreter::Type_Code codeword = 3388997790;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getalteration()
    {
        Interpreter::Type_Code codeword = 3388997785;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getangle(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997994;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getarmorbonus()
    {
        Interpreter::Type_Code codeword = 3388998260;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getarmorer()
    {
        Interpreter::Type_Code codeword = 3388997775;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getarmortype(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998097;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getathletics()
    {
        Interpreter::Type_Code codeword = 3388997782;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getattackbonus()
    {
        Interpreter::Type_Code codeword = 3388998266;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getattacked()
    {
        Interpreter::Type_Code codeword = 3388998099;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getaxe()
    {
        Interpreter::Type_Code codeword = 3388997780;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getblightdisease()
    {
        Interpreter::Type_Code codeword = 3388998058;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getblindness()
    {
        Interpreter::Type_Code codeword = 3388998263;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getblock()
    {
        Interpreter::Type_Code codeword = 3388997774;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getbluntweapon()
    {
        Interpreter::Type_Code codeword = 3388997778;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getbuttonpressed()
    {
        Interpreter::Type_Code codeword = 3388997943;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getcastpenalty()
    {
        Interpreter::Type_Code codeword = 3388998261;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getchameleon()
    {
        Interpreter::Type_Code codeword = 3388998255;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getcollidingactor()
    {
        Interpreter::Type_Code codeword = 3388998226;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getcollidingpc()
    {
        Interpreter::Type_Code codeword = 3388998224;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getcommondisease()
    {
        Interpreter::Type_Code codeword = 3388998056;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getconjuration()
    {
        Interpreter::Type_Code codeword = 3388997787;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getcurrentaipackage()
    {
        Interpreter::Type_Code codeword = 3388998127;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getcurrenttime()
    {
        Interpreter::Type_Code codeword = 3388998109;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getcurrentweather()
    {
        Interpreter::Type_Code codeword = 3388997951;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getdeadcount(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998051;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getdefendbonus()
    {
        Interpreter::Type_Code codeword = 3388998267;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getdestruction()
    {
        Interpreter::Type_Code codeword = 3388997784;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getdetected(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998129;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getdisposition()
    {
        Interpreter::Type_Code codeword = 3388998054;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer geteffect(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998095;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getenchant()
    {
        Interpreter::Type_Code codeword = 3388997783;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getendurance()
    {
        Interpreter::Type_Code codeword = 3388997676;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getfactionreaction(std::string arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3388998211;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getfatigue()
    {
        Interpreter::Type_Code codeword = 3388997721;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Float getfatiguegetratio()
    {
        Interpreter::Type_Code codeword = 3388997745;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getfight()
    {
        Interpreter::Type_Code codeword = 3388998081;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getflee()
    {
        Interpreter::Type_Code codeword = 3388998083;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getflying()
    {
        Interpreter::Type_Code codeword = 3388998259;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getforcejump()
    {
        Interpreter::Type_Code codeword = 3388998240;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getforcemovejump()
    {
        Interpreter::Type_Code codeword = 3388998242;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getforcerun()
    {
        Interpreter::Type_Code codeword = 3388998091;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getforcesneak()
    {
        Interpreter::Type_Code codeword = 3388998092;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer gethandtohand()
    {
        Interpreter::Type_Code codeword = 3388997800;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float gethealth()
    {
        Interpreter::Type_Code codeword = 3388997719;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Float gethealthgetratio()
    {
        Interpreter::Type_Code codeword = 3388997743;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getheavyarmor()
    {
        Interpreter::Type_Code codeword = 3388997777;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer gethello()
    {
        Interpreter::Type_Code codeword = 3388998079;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getillusion()
    {
        Interpreter::Type_Code codeword = 3388997786;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getintelligence()
    {
        Interpreter::Type_Code codeword = 3388997672;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getinterior()
    {
        Interpreter::Type_Code codeword = 3388997937;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getinvisible()
    {
        Interpreter::Type_Code codeword = 3388998265;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getitemcount(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997752;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getjournalindex(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997941;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlevel()
    {
        Interpreter::Type_Code codeword = 3388998028;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlightarmor()
    {
        Interpreter::Type_Code codeword = 3388997795;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlineofsight(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998178;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlocked()
    {
        Interpreter::Type_Code codeword = 3388998087;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlongblade()
    {
        Interpreter::Type_Code codeword = 3388997779;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getlos(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998178;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getluck()
    {
        Interpreter::Type_Code codeword = 3388997678;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getmagicka()
    {
        Interpreter::Type_Code codeword = 3388997720;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Float getmagickagetratio()
    {
        Interpreter::Type_Code codeword = 3388997744;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getmarksman()
    {
        Interpreter::Type_Code codeword = 3388997797;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getmasserphase()
    {
        Interpreter::Type_Code codeword = 3388997668;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getmediumarmor()
    {
        Interpreter::Type_Code codeword = 3388997776;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getmercantile()
    {
        Interpreter::Type_Code codeword = 3388997798;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getmysticism()
    {
        Interpreter::Type_Code codeword = 3388997788;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getparalysis()
    {
        Interpreter::Type_Code codeword = 3388998264;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpccell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997942;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getpccrimelevel()
    {
        Interpreter::Type_Code codeword = 3388998124;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getpcfacrep(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254784512;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcinjail()
    {
        Interpreter::Type_Code codeword = 3388998206;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcjumping()
    {
        Interpreter::Type_Code codeword = 3388998195;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcrank(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254783488;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcrunning()
    {
        Interpreter::Type_Code codeword = 3388998089;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcsleep()
    {
        Interpreter::Type_Code codeword = 3388998047;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpcsneaking()
    {
        Interpreter::Type_Code codeword = 3388998090;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpctraveling()
    {
        Interpreter::Type_Code codeword = 3388998207;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getpersonality()
    {
        Interpreter::Type_Code codeword = 3388997677;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayercontrolsdisabled()
    {
        Interpreter::Type_Code codeword = 3388998005;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayerfightingdisabled()
    {
        Interpreter::Type_Code codeword = 3388998006;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayerjumpingdisabled()
    {
        Interpreter::Type_Code codeword = 3388998007;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayerlookingdisabled()
    {
        Interpreter::Type_Code codeword = 3388998008;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayermagicdisabled()
    {
        Interpreter::Type_Code codeword = 3388998009;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getplayerviewswitchdisabled()
    {
        Interpreter::Type_Code codeword = 3388998010;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getpos(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998032;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getrace(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998105;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getreputation()
    {
        Interpreter::Type_Code codeword = 3388998065;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistblight()
    {
        Interpreter::Type_Code codeword = 3388998249;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistcorprus()
    {
        Interpreter::Type_Code codeword = 3388998250;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistdisease()
    {
        Interpreter::Type_Code codeword = 3388998248;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistfire()
    {
        Interpreter::Type_Code codeword = 3388998245;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistfrost()
    {
        Interpreter::Type_Code codeword = 3388998246;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistmagicka()
    {
        Interpreter::Type_Code codeword = 3388998244;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistnormalweapons()
    {
        Interpreter::Type_Code codeword = 3388998253;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistparalysis()
    {
        Interpreter::Type_Code codeword = 3388998252;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistpoison()
    {
        Interpreter::Type_Code codeword = 3388998251;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getresistshock()
    {
        Interpreter::Type_Code codeword = 3388998247;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getrestoration()
    {
        Interpreter::Type_Code codeword = 3388997789;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getscale()
    {
        Interpreter::Type_Code codeword = 3388997992;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getsecundaphase()
    {
        Interpreter::Type_Code codeword = 3388997669;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getsecurity()
    {
        Interpreter::Type_Code codeword = 3388997792;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getshortblade()
    {
        Interpreter::Type_Code codeword = 3388997796;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getsilence()
    {
        Interpreter::Type_Code codeword = 3388998262;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getsneak()
    {
        Interpreter::Type_Code codeword = 3388997793;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getsoundplaying(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997643;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspear()
    {
        Interpreter::Type_Code codeword = 3388997781;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspeechcraft()
    {
        Interpreter::Type_Code codeword = 3388997799;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspeed()
    {
        Interpreter::Type_Code codeword = 3388997675;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997963;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspelleffects(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998107;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getspellreadied()
    {
        Interpreter::Type_Code codeword = 3388998193;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getsquareroot(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998119;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getstandingactor()
    {
        Interpreter::Type_Code codeword = 3388998158;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getstandingpc()
    {
        Interpreter::Type_Code codeword = 3388998156;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getstartingangle(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998160;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Float getstartingpos(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998036;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getstat(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998222;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getstrength()
    {
        Interpreter::Type_Code codeword = 3388997671;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getsuperjump()
    {
        Interpreter::Type_Code codeword = 3388998258;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getswimspeed()
    {
        Interpreter::Type_Code codeword = 3388998257;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer gettarget(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998200;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getunarmored()
    {
        Interpreter::Type_Code codeword = 3388997791;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getvanitymodedisabled()
    {
        Interpreter::Type_Code codeword = 3388998011;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getwaterbreathing()
    {
        Interpreter::Type_Code codeword = 3388998254;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getwaterlevel()
    {
        Interpreter::Type_Code codeword = 3388997953;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    Interpreter::Type_Integer getwaterwalking()
    {
        Interpreter::Type_Code codeword = 3388998256;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getweapondrawn()
    {
        Interpreter::Type_Code codeword = 3388998103;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getweapontype()
    {
        Interpreter::Type_Code codeword = 3388998112;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getwerewolfkills()
    {
        Interpreter::Type_Code codeword = 3388998114;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer getwillpower()
    {
        Interpreter::Type_Code codeword = 3388997673;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Float getwindspeed()
    {
        Interpreter::Type_Code codeword = 3388998162;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mFloat;
    }
    void goodbye()
    {
        Interpreter::Type_Code codeword = 3388997970;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void gotojail()
    {
        Interpreter::Type_Code codeword = 3388998197;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer hasitemequipped(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998101;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer hassoulgem(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998110;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer hitattemptonme(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998393;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer hitonme(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998163;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void hurtcollidingactor(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998230;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void hurtstandingactor(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998228;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer iswerewolf()
    {
        Interpreter::Type_Code codeword = 3388998141;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void journal(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388997939;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void lock(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3254780928;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void loopgroup(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3254781952;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void lowerrank()
    {
        Interpreter::Type_Code codeword = 3388998122;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void menutest(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3254791168;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modacrobatics(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997902;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modagility(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997706;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modalarm(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998077;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modalchemy(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997898;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modalteration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997893;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modarmorbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998356;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modarmorer(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997883;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modathletics(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997890;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modattackbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998362;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modaxe(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997888;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modblindness(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998359;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modblock(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997882;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modbluntweapon(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997886;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modcastpenalty(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998357;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modchameleon(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998351;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modconjuration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997895;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modcurrentfatigue(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997739;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modcurrenthealth(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997737;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modcurrentmagicka(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997738;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void moddefendbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998363;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void moddestruction(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997892;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void moddisposition(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997965;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modenchant(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997891;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modendurance(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997708;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modfactionreaction(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3388998210;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modfatigue(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997733;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modfight(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998073;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modflee(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998075;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modflying(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998355;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modhandtohand(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997908;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modhealth(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997731;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modheavyarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997885;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modhello(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998071;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modillusion(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997894;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modintelligence(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997704;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modinvisible(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998361;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modlightarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997903;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modlongblade(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997887;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modluck(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997710;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modmagicka(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997732;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modmarksman(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997905;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modmediumarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997884;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modmercantile(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997906;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modmysticism(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997896;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modparalysis(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998360;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modpccrimelevel(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998126;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modpcfacrep(Interpreter::Type_Integer arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3254785536;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modpersonality(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997709;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modregion(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Integer arg2, Interpreter::Type_Integer arg3, Interpreter::Type_Integer arg4, Interpreter::Type_Integer arg5, Interpreter::Type_Integer arg6, Interpreter::Type_Integer arg7, Interpreter::Type_Integer arg8, Interpreter::Type_Integer arg9, Interpreter::Type_Integer arg10)
    {
        Interpreter::Type_Code codeword = 3254789632;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 11;
        uint optionalArgCount = 10;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg10!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg10);
            argumentsPassed++;
        }
        if (arg9!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg9);
            argumentsPassed++;
        }
        if (arg8!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg8);
            argumentsPassed++;
        }
        if (arg7!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg7);
            argumentsPassed++;
        }
        if (arg6!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg6);
            argumentsPassed++;
        }
        if (arg5!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modreputation(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998062;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistblight(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998345;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistcorprus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998346;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistdisease(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998344;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistfire(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998341;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistfrost(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998342;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistmagicka(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998340;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistnormalweapons(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998349;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistparalysis(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998348;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistpoison(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998347;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modresistshock(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998343;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modrestoration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997897;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modscale(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998115;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modsecurity(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997900;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modshortblade(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997904;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modsilence(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998358;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modsneak(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997901;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modspear(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997889;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modspeechcraft(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997907;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modspeed(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997707;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modstrength(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997703;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modsuperjump(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998354;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modswimspeed(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998353;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modunarmored(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997899;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modwaterbreathing(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998350;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modwaterlevel(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997955;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modwaterwalking(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998352;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void modwillpower(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997705;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void move(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388998150;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void moveworld(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388998152;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer onactivate()
    {
        Interpreter::Type_Code codeword = 3388997645;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer ondeath()
    {
        Interpreter::Type_Code codeword = 3388998140;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer onknockout()
    {
        Interpreter::Type_Code codeword = 3388998208;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    Interpreter::Type_Integer onmurder()
    {
        Interpreter::Type_Code codeword = 3388998217;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void payfine()
    {
        Interpreter::Type_Code codeword = 3388998198;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void payfinethief()
    {
        Interpreter::Type_Code codeword = 3388998199;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void pcclearexpelled(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254787072;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void pcexpell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254786560;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer pcexpelled(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254786048;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void pcforce1stperson()
    {
        Interpreter::Type_Code codeword = 3388998390;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void pcforce3rdperson()
    {
        Interpreter::Type_Code codeword = 3388998391;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer pcget3rdperson()
    {
        Interpreter::Type_Code codeword = 3388998392;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void pcjoinfaction(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254783232;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void pclowerrank(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254782976;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void pcraiserank(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3254782720;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void placeatme(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
    {
        Interpreter::Type_Code codeword = 3388998045;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 4;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void placeatpc(std::string arg0, Interpreter::Type_Integer arg1, Interpreter::Type_Float arg2, Interpreter::Type_Integer arg3)
    {
        Interpreter::Type_Code codeword = 3388998044;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 4;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg3!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void placeitem(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4)
    {
        Interpreter::Type_Code codeword = 3388998043;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 5;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void placeitemcell(std::string arg0, std::string arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, Interpreter::Type_Float arg4, Interpreter::Type_Float arg5)
    {
        Interpreter::Type_Code codeword = 3388998042;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 6;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg5!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg5);
            argumentsPassed++;
        }
        if (arg4!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg4);
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playbink(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388998135;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playgroup(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3254781440;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playloopsound3d(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997640;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playloopsound3dvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
    {
        Interpreter::Type_Code codeword = 3388997641;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playsound(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997636;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playsound3d(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997638;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playsound3dvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
    {
        Interpreter::Type_Code codeword = 3388997639;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void playsoundvp(std::string arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2)
    {
        Interpreter::Type_Code codeword = 3388997637;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void position(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3)
    {
        Interpreter::Type_Code codeword = 3388998038;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 4;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void positioncell(Interpreter::Type_Float arg0, Interpreter::Type_Float arg1, Interpreter::Type_Float arg2, Interpreter::Type_Float arg3, std::string arg4)
    {
        Interpreter::Type_Code codeword = 3388998040;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 5;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg4!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg4));
            argumentsPassed++;
        }
        if (arg3!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg3);
            argumentsPassed++;
        }
        if (arg2!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void ra()
    {
        Interpreter::Type_Code codeword = 3388998388;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void raiserank()
    {
        Interpreter::Type_Code codeword = 3388998120;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removeeffects(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998189;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removefromlevcreature(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3388998396;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removefromlevitem(std::string arg0, std::string arg1, Interpreter::Type_Integer arg2)
    {
        Interpreter::Type_Code codeword = 3388998398;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 3;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg2!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg2);
            argumentsPassed++;
        }
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removeitem(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388997754;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removesoulgem(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3254789888;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removespell(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997961;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void removespelleffects(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998187;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void resetactors()
    {
        Interpreter::Type_Code codeword = 3388998388;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void resurrect()
    {
        Interpreter::Type_Code codeword = 3388998191;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void rotate(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388998143;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void rotateworld(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388998145;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer samefaction()
    {
        Interpreter::Type_Code codeword = 3388998069;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void say(std::string arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3388997633;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer saydone()
    {
        Interpreter::Type_Code codeword = 3388997634;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
    void setacrobatics(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997848;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setagility(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997690;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setalarm(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997986;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setalchemy(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997844;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setalteration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997839;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setangle(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388997990;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setarmorbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998308;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setarmorer(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997829;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setathletics(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997836;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setatstart()
    {
        Interpreter::Type_Code codeword = 3388998147;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setattackbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998314;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setaxe(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997834;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setblindness(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998311;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setblock(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997828;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setbluntweapon(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997832;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setcastpenalty(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998309;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setchameleon(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998303;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setconjuration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997841;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setdefendbonus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998315;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setdelete(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998117;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setdestruction(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997838;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setdisposition(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998052;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setenchant(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997837;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setendurance(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997692;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setfatigue(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997727;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setfight(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997982;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setflee(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997984;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setflying(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998307;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void sethandtohand(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997854;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void sethealth(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997725;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setheavyarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997831;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void sethello(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997980;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setillusion(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997840;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setintelligence(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997688;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setinvisible(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998313;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setjournalindex(std::string arg0, Interpreter::Type_Integer arg1)
    {
        Interpreter::Type_Code codeword = 3388997940;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setlevel(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998030;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setlightarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997849;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setlongblade(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997833;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setluck(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997694;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setmagicka(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997726;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setmarksman(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997851;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setmediumarmor(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997830;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setmercantile(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997852;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setmysticism(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997842;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setparalysis(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998312;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setpccrimelevel(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388998125;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setpcfacrep(Interpreter::Type_Integer arg0, std::string arg1)
    {
        Interpreter::Type_Code codeword = 3254785024;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 1;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg1));
            argumentsPassed++;
        }
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setpersonality(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997693;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setpos(std::string arg0, Interpreter::Type_Float arg1)
    {
        Interpreter::Type_Code codeword = 3388998034;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 2;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg1!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg1);
            argumentsPassed++;
        }
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setreputation(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998061;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistblight(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998297;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistcorprus(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998298;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistdisease(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998296;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistfire(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998293;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistfrost(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998294;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistmagicka(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998292;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistnormalweapons(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998301;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistparalysis(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998300;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistpoison(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998299;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setresistshock(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998295;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setrestoration(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997843;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setscale(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997988;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setsecurity(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997846;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setshortblade(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997850;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setsilence(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998310;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setsneak(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997847;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setspear(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997835;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setspeechcraft(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997853;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setspeed(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997691;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setstrength(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997687;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setsuperjump(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998306;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setswimspeed(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998305;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setunarmored(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997845;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setwaterbreathing(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998302;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setwaterlevel(Interpreter::Type_Float arg0)
    {
        Interpreter::Type_Code codeword = 3388997954;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushFloat(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setwaterwalking(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388998304;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setwerewolfacrobatics()
    {
        Interpreter::Type_Code codeword = 3388998171;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void setwillpower(Interpreter::Type_Integer arg0)
    {
        Interpreter::Type_Code codeword = 3388997689;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!=-123456)
        {
            Compiler::Generator.pushInt(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void showmap(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998048;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void showrestmenu()
    {
        Interpreter::Type_Code codeword = 3388997656;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void showvars()
    {
        Interpreter::Type_Code codeword = 3388998173;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void skipanim()
    {
        Interpreter::Type_Code codeword = 3388997944;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void startcombat(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388998202;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void stopcombat()
    {
        Interpreter::Type_Code codeword = 3388998204;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void stopsound(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997642;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, Misc::StringUtils::lowerCase (arg0));
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void streammusic(std::string arg0)
    {
        Interpreter::Type_Code codeword = 3388997635;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 1;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        if (arg0!="OPTIONAL_FLAG")
        {
            Compiler::Generator.pushString(code, literals, arg0);
            argumentsPassed++;
        }
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void sv()
    {
        Interpreter::Type_Code codeword = 3388998173;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tai()
    {
        Interpreter::Type_Code codeword = 3388998180;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tcb()
    {
        Interpreter::Type_Code codeword = 3388998060;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tcg()
    {
        Interpreter::Type_Code codeword = 3388997938;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tcl()
    {
        Interpreter::Type_Code codeword = 3388997936;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tfh()
    {
        Interpreter::Type_Code codeword = 3388997969;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tfow()
    {
        Interpreter::Type_Code codeword = 3388997957;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tgm()
    {
        Interpreter::Type_Code codeword = 3388998175;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tm()
    {
        Interpreter::Type_Code codeword = 3388998219;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void toggleai()
    {
        Interpreter::Type_Code codeword = 3388998180;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglecollision()
    {
        Interpreter::Type_Code codeword = 3388997936;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglecollisionboxes()
    {
        Interpreter::Type_Code codeword = 3388998060;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglecollisiongrid()
    {
        Interpreter::Type_Code codeword = 3388997938;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglefogofwar()
    {
        Interpreter::Type_Code codeword = 3388997957;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglefullhelp()
    {
        Interpreter::Type_Code codeword = 3388997969;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglegodmode()
    {
        Interpreter::Type_Code codeword = 3388998175;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglemenus()
    {
        Interpreter::Type_Code codeword = 3388998219;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglepathgrid()
    {
        Interpreter::Type_Code codeword = 3388997958;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglesky()
    {
        Interpreter::Type_Code codeword = 3388997665;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglevanitymode()
    {
        Interpreter::Type_Code codeword = 3388998004;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglewater()
    {
        Interpreter::Type_Code codeword = 3388997956;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void togglewireframe()
    {
        Interpreter::Type_Code codeword = 3388997947;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void toggleworld()
    {
        Interpreter::Type_Code codeword = 3388998389;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tpg()
    {
        Interpreter::Type_Code codeword = 3388997958;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void ts()
    {
        Interpreter::Type_Code codeword = 3388997665;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void turnmoonred()
    {
        Interpreter::Type_Code codeword = 3388997667;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void turnmoonwhite()
    {
        Interpreter::Type_Code codeword = 3388997666;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tvm()
    {
        Interpreter::Type_Code codeword = 3388998004;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void tw()
    {
        Interpreter::Type_Code codeword = 3388998389;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void twa()
    {
        Interpreter::Type_Code codeword = 3388997956;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void twf()
    {
        Interpreter::Type_Code codeword = 3388997947;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void undowerewolf()
    {
        Interpreter::Type_Code codeword = 3388998169;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void unlock()
    {
        Interpreter::Type_Code codeword = 3388997772;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    void wakeuppc()
    {
        Interpreter::Type_Code codeword = 3388998050;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return;
    }
    Interpreter::Type_Integer xbox()
    {
        Interpreter::Type_Code codeword = 3388997644;//codeword without arguments
        Literals& literals;
        std::vector<Interpreter::Type_Code> code;
        uint argCount = 0;
        uint optionalArgCount = 0;
        uint argumentsPassed = 0;
        uint optionalArgumentsPassed = 0;
        optionalArgumentsPassed = argumentsPassed-(argCount-optionalArgCount);
        // adds number of arguments as argument to the codeword, similar to how generateInstructionCode does it
        if (argumentsPassed > 0) codeword= codeword | (optionalArgumentsPassed & 0xff);
        //now append codeword to code, append literals to code, create header words and place at head of code see Output::getCode()
        interpreter.run(&code[0], code.size(), context);//todo - get the runtime stack!
        return runtime[0].mInteger;
    }
}