add runtime assembly compiler

Assembly.cpp

@@ -0,0 +1,7447 @@
+#include "Assembly.h"
+
+#include "InMemoryBuffer.h"
+
+struct MachineCodeInstruction
+{
+    bool needsRex;
+    char opcode[3];
+    char opcodeLength;
+    bool needsModRM;
+    char modRM;
+    bool sibNeeded;
+    char sib;
+    char disp[4];
+    char dispLength;
+    char imm[8];
+    char immLength;
+    bool operandSizeOverride;
+    bool errIfRex;
+    bool errIfNoRex;
+    bool exR;
+    bool exX;
+    bool exB;
+    bool vexL;
+    bool exWE;
+    int vexVVVV;
+    char vexPP;
+    bool needsVex;
+
+    void write(Framework::StreamWriter& writer) const
+    {
+        if (operandSizeOverride)
+        {
+            char prefix = 0x66;
+            writer.schreibe(&prefix, 1);
+        }
+        if (needsRex && !needsVex)
+        {
+            char rex = 0b01000000 | ((exWE & 0b1) << 3) | ((exR & 0b1) << 2)
+                     | ((exX & 0b1) << 1) | (exB & 0b1);
+            writer.schreibe(&rex, 1);
+        }
+        int opCodeOffset = 0;
+        if (needsVex)
+        {
+            char vexMapSelect = 0;
+            if (opcode[0] == 0x0F)
+            {
+                opCodeOffset = 1;
+                vexMapSelect = 1;
+                if (opcode[1] == 0x38)
+                {
+                    vexMapSelect = 2;
+                    opCodeOffset = 2;
+                }
+                else if (opcode[1] == 0x3A)
+                {
+                    vexMapSelect = 3;
+                    opCodeOffset = 2;
+                }
+            }
+            if (exX || exB || exWE || vexMapSelect != 1)
+            {
+                // 3-byte VEX
+                char vex2[3];
+                vex2[0] = (char)0xC4;
+                vex2[1]
+                    = (((~(char)exR) & 0b1) << 7) | (((~(char)exX) & 0b1) << 6)
+                    | (((~(char)exB) & 0b1) << 5) | (vexMapSelect & 0b11111);
+                vex2[2] = ((exWE & 0b1) << 7)
+                        | (((~(char)vexVVVV) & 0b1111) << 3)
+                        | ((vexL & 0b1) << 2) | (vexPP & 0b11);
+                writer.schreibe(vex2, 3);
+            }
+            else
+            {
+                // 2-byte VEX
+                char vex2[2];
+                vex2[0] = (char)0xC5;
+                vex2[1] = (((~(char)exR) & 0b1) << 7)
+                        | (((~(char)vexVVVV) & 0b1111) << 3)
+                        | ((vexL & 0b1) << 2) | (vexPP & 0b11);
+                writer.schreibe(vex2, 2);
+            }
+        }
+        writer.schreibe(opcode + opCodeOffset, opcodeLength - opCodeOffset);
+        if (needsModRM)
+        {
+            writer.schreibe(&modRM, 1);
+        }
+        if (sibNeeded)
+        {
+            writer.schreibe(&sib, 1);
+        }
+        if (dispLength > 0)
+        {
+            writer.schreibe(disp, dispLength);
+        }
+        if (immLength > 0)
+        {
+            writer.schreibe(imm, immLength);
+        }
+    }
+
+    int calculateSize() const
+    {
+        int size = 0;
+        if (operandSizeOverride)
+        {
+            size += 1;
+        }
+        if (needsRex && !needsVex)
+        {
+            size += 1;
+        }
+        int opCodeOffset = 0;
+        if (needsVex)
+        {
+            char vexMapSelect = 0;
+            if (opcode[0] == 0x0F)
+            {
+                opCodeOffset = 1;
+                vexMapSelect = 1;
+                if (opcode[1] == 0x38)
+                {
+                    vexMapSelect = 2;
+                    opCodeOffset = 2;
+                }
+                else if (opcode[1] == 0x3A)
+                {
+                    vexMapSelect = 3;
+                    opCodeOffset = 2;
+                }
+            }
+            if (exX || exB || exWE || vexMapSelect != 1)
+            {
+                size += 3;
+            }
+            else
+            {
+                size += 2;
+            }
+        }
+        size += opcodeLength - opCodeOffset;
+        if (needsModRM)
+        {
+            size += 1;
+        }
+        if (sibNeeded)
+        {
+            size += 1;
+        }
+        size += dispLength;
+        size += immLength;
+        return size;
+    }
+};
+
+enum OperandEncoding
+{
+    UNDEFINED,
+    MODRM_REG,
+    MODRM_RM,
+    VEX_VVVV,
+    OPCODE_RD,
+    // EVEX_VVVV,
+    IMM8,
+    IMM16,
+    IMM32,
+    IMM64,
+};
+
+enum OperandRW
+{
+    NONE = 0,
+    READ = 1,
+    WRITE = 2,
+    READWRITE = 3,
+};
+
+class MachineCodeTableEntry
+{
+private:
+    int numArgs;
+    std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+        op1Validator;
+    std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+        op2Validator;
+    std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+        op3Validator;
+    std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+        op4Validator;
+    bool vex;
+    bool vexL;
+    char vexPP;
+    bool rexW;
+    char rmReg;
+    char opcode[3];
+    char opcodeLength;
+    OperandEncoding op1Encoding;
+    OperandEncoding op2Encoding;
+    OperandEncoding op3Encoding;
+    OperandEncoding op4Encoding;
+    OperandRW op1RW;
+    OperandRW op2RW;
+    OperandRW op3RW;
+    OperandRW op4RW;
+    std::vector<Framework::Assembly::GPRegister> impliedReadGPRegs;
+    std::vector<Framework::Assembly::GPRegister> impliedWriteGPRegs;
+    std::vector<Framework::Assembly::FPRegister> impliedReadFPRegs;
+    std::vector<Framework::Assembly::FPRegister> impliedWriteFPRegs;
+    bool operandSizeOverride;
+
+public:
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg)
+        : numArgs(0),
+          rexW(rexW),
+          rmReg(rmReg),
+          opcodeLength(opcodeLength),
+          operandSizeOverride(operandSizeOverride),
+          vex(vex),
+          vexL(vexL),
+          vexPP(vexPP),
+          op1Encoding(UNDEFINED),
+          op2Encoding(UNDEFINED),
+          op3Encoding(UNDEFINED),
+          op4Encoding(UNDEFINED),
+          op1RW(NONE),
+          op2RW(NONE),
+          op3RW(NONE),
+          op4RW(NONE)
+    {
+        this->opcode[0] = (char)(opcode & 0xFF);
+        this->opcode[1] = (char)((opcode >> 8) & 0xFF);
+        this->opcode[2] = (char)((opcode >> 16) & 0xFF);
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedReadGPRegs,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedWriteGPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedReadFPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedWriteFPRegs)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg)
+    {
+        this->opcode[0] = (char)(opcode & 0xFF);
+        this->opcode[1] = (char)((opcode >> 8) & 0xFF);
+        this->opcode[2] = (char)((opcode >> 16) & 0xFF);
+        this->impliedReadGPRegs = impliedReadGPRegs;
+        this->impliedWriteGPRegs = impliedWriteGPRegs;
+        this->impliedReadFPRegs = impliedReadFPRegs;
+        this->impliedWriteFPRegs = impliedWriteFPRegs;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg)
+    {
+        numArgs = 1;
+        this->op1Validator = op1Validator;
+        this->op1Encoding = op1Encoding;
+        this->op1RW = op1RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedReadGPRegs,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedWriteGPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedReadFPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedWriteFPRegs,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              impliedReadGPRegs,
+              impliedWriteGPRegs,
+              impliedReadFPRegs,
+              impliedWriteFPRegs)
+    {
+        numArgs = 1;
+        this->op1Validator = op1Validator;
+        this->op1Encoding = op1Encoding;
+        this->op1RW = op1RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              op1Validator,
+              op1Encoding,
+              op1RW)
+    {
+        numArgs = 2;
+        this->op2Validator = op2Validator;
+        this->op2Encoding = op2Encoding;
+        this->op2RW = op2RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedReadGPRegs,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedWriteGPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedReadFPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedWriteFPRegs,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              impliedReadGPRegs,
+              impliedWriteGPRegs,
+              impliedReadFPRegs,
+              impliedWriteFPRegs,
+              op1Validator,
+              op1Encoding,
+              op1RW)
+    {
+        numArgs = 2;
+        this->op2Validator = op2Validator;
+        this->op2Encoding = op2Encoding;
+        this->op2RW = op2RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op3Validator,
+        OperandEncoding op3Encoding,
+        OperandRW op3RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              op1Validator,
+              op1Encoding,
+              op1RW,
+              op2Validator,
+              op2Encoding,
+              op2RW)
+    {
+        numArgs = 3;
+        this->op3Validator = op3Validator;
+        this->op3Encoding = op3Encoding;
+        this->op3RW = op3RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedReadGPRegs,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedWriteGPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedReadFPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedWriteFPRegs,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op3Validator,
+        OperandEncoding op3Encoding,
+        OperandRW op3RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              impliedReadGPRegs,
+              impliedWriteGPRegs,
+              impliedReadFPRegs,
+              impliedWriteFPRegs,
+              op1Validator,
+              op1Encoding,
+              op1RW,
+              op2Validator,
+              op2Encoding,
+              op2RW)
+    {
+        numArgs = 3;
+        this->op3Validator = op3Validator;
+        this->op3Encoding = op3Encoding;
+        this->op3RW = op3RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op3Validator,
+        OperandEncoding op3Encoding,
+        OperandRW op3RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op4Validator,
+        OperandEncoding op4Encoding,
+        OperandRW op4RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              op1Validator,
+              op1Encoding,
+              op1RW,
+              op2Validator,
+              op2Encoding,
+              op2RW,
+              op3Validator,
+              op3Encoding,
+              op3RW)
+    {
+        numArgs = 4;
+        this->op4Validator = op4Validator;
+        this->op4Encoding = op4Encoding;
+        this->op4RW = op4RW;
+    }
+
+    MachineCodeTableEntry(bool rexW,
+        int opcode,
+        char opcodeLength,
+        bool operandSizeOverride,
+        bool vex,
+        bool vexL,
+        char vexPP,
+        char rmReg,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedReadGPRegs,
+        std::initializer_list<Framework::Assembly::GPRegister>
+            impliedWriteGPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedReadFPRegs,
+        std::initializer_list<Framework::Assembly::FPRegister>
+            impliedWriteFPRegs,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op1Validator,
+        OperandEncoding op1Encoding,
+        OperandRW op1RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op2Validator,
+        OperandEncoding op2Encoding,
+        OperandRW op2RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op3Validator,
+        OperandEncoding op3Encoding,
+        OperandRW op3RW,
+        std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+            op4Validator,
+        OperandEncoding op4Encoding,
+        OperandRW op4RW)
+        : MachineCodeTableEntry(rexW,
+              opcode,
+              opcodeLength,
+              operandSizeOverride,
+              vex,
+              vexL,
+              vexPP,
+              rmReg,
+              impliedReadGPRegs,
+              impliedWriteGPRegs,
+              impliedReadFPRegs,
+              impliedWriteFPRegs,
+              op1Validator,
+              op1Encoding,
+              op1RW,
+              op2Validator,
+              op2Encoding,
+              op2RW,
+              op3Validator,
+              op3Encoding,
+              op3RW)
+    {
+        numArgs = 4;
+        this->op4Validator = op4Validator;
+        this->op4Encoding = op4Encoding;
+        this->op4RW = op4RW;
+    }
+
+    MachineCodeTableEntry(const MachineCodeTableEntry& other) = default;
+
+    bool matches(int numArgs,
+        const std::vector<Framework::Assembly::OperationArgument*>& args) const
+    {
+        if (numArgs != this->numArgs)
+        {
+            return false;
+        }
+        if (numArgs >= 1 && !op1Validator(*args[0]))
+        {
+            return false;
+        }
+        if (numArgs >= 2 && !op2Validator(*args[1]))
+        {
+            return false;
+        }
+        if (numArgs >= 3 && !op3Validator(*args[2]))
+        {
+            return false;
+        }
+        if (numArgs >= 4 && !op4Validator(*args[3]))
+        {
+            return false;
+        }
+        return true;
+    }
+
+    OperandRW getOperandRW(int index) const
+    {
+        switch (index)
+        {
+        case 0:
+            return op1RW;
+        case 1:
+            return op2RW;
+        case 2:
+            return op3RW;
+        case 3:
+            return op4RW;
+        default:
+            return NONE;
+        }
+    }
+
+    const std::vector<Framework::Assembly::GPRegister>&
+    getImpliedReadGPRegs() const
+    {
+        return impliedReadGPRegs;
+    }
+
+    const std::vector<Framework::Assembly::GPRegister>&
+    getImpliedWriteGPRegs() const
+    {
+        return impliedWriteGPRegs;
+    }
+
+    const std::vector<Framework::Assembly::FPRegister>&
+    getImpliedReadFPRegs() const
+    {
+        return impliedReadFPRegs;
+    }
+
+    const std::vector<Framework::Assembly::FPRegister>&
+    getImpliedWriteFPRegs() const
+    {
+        return impliedWriteFPRegs;
+    }
+
+    friend class OperationCodeTable;
+};
+
+class OperationCodeTable : public Framework::ReferenceCounter
+{
+public:
+    thread_local static Framework::RCArray<OperationCodeTable>
+        machineCodeTranslationTable;
+
+private:
+    Framework::Assembly::Operation op;
+    std::vector<MachineCodeTableEntry> entries;
+
+public:
+    OperationCodeTable(Framework::Assembly::Operation op,
+        std::initializer_list<MachineCodeTableEntry> entries)
+        : ReferenceCounter(),
+          op(op),
+          entries(entries)
+    {}
+
+    MachineCodeInstruction getInstruction(
+        const std::vector<Framework::Assembly::OperationArgument*>& args,
+        const Framework::Assembly::AssemblyBlock* codeBlock,
+        const Framework::Assembly::Instruction* current)
+    {
+        MachineCodeInstruction result;
+        memset(&result, 0, sizeof(MachineCodeInstruction));
+        const MachineCodeTableEntry& entry = getEntry(args, codeBlock, current);
+        result.needsVex = entry.vex;
+        result.vexL = entry.vexL;
+        result.vexPP = entry.vexPP;
+        result.needsRex = entry.rexW;
+        result.exWE = entry.rexW;
+        result.modRM = entry.rmReg << 3;
+        if (entry.rmReg)
+        {
+            result.needsModRM = true;
+        }
+        memcpy(result.opcode, entry.opcode, 3);
+        result.opcodeLength = entry.opcodeLength;
+        result.operandSizeOverride = entry.operandSizeOverride;
+        for (int i = 0; i < args.size(); i++)
+        {
+            OperandEncoding encoding = UNDEFINED;
+            switch (i)
+            {
+            case 0:
+                encoding = entry.op1Encoding;
+                break;
+            case 1:
+                encoding = entry.op2Encoding;
+                break;
+            case 2:
+                encoding = entry.op3Encoding;
+                break;
+            case 3:
+                encoding = entry.op4Encoding;
+                break;
+            }
+            switch (encoding)
+            {
+            case MODRM_REG:
+                encodeModRM_REG(result, args[i], i + 1);
+                break;
+            case MODRM_RM:
+                encodeModRM_RM(result, args[i], i + 1);
+                break;
+            case VEX_VVVV:
+                encodeVex_VVVV(result, args[i], i + 1);
+                break;
+            case OPCODE_RD:
+                encodeOpcode_RD(result, args[i], i + 1);
+                break;
+            case IMM8:
+                encodeIMM8(result, args[i], i + 1);
+                break;
+            case IMM16:
+                encodeIMM16(result, args[i], i + 1);
+                break;
+            case IMM32:
+                encodeIMM32(result, args[i], i + 1);
+                break;
+            case IMM64:
+                encodeIMM64(result, args[i], i + 1);
+                break;
+            }
+        }
+        if (result.errIfNoRex && !result.needsRex)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Instruction " << op
+                          << " has no REX prefix and can not address "
+                             "LOWER8 of registers RSP, RBP, RSI or RDI";
+            throw err->getText();
+        }
+        if (result.errIfRex && result.needsRex)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Instruction " << op
+                          << " has a REX prefix and can not address "
+                             "HIGHER8 of registers RAX, RBX, RCX or RDX";
+            throw err->getText();
+        }
+        return result;
+    }
+
+    virtual MachineCodeTableEntry& getEntry(
+        const std::vector<Framework::Assembly::OperationArgument*>& args,
+        const Framework::Assembly::AssemblyBlock* codeBlock,
+        const Framework::Assembly::Instruction* current)
+    {
+        MachineCodeInstruction result;
+        memset(&result, 0, sizeof(MachineCodeInstruction));
+        for (MachineCodeTableEntry& entry : entries)
+        {
+            if (entry.matches((int)args.size(), args))
+            {
+                return entry;
+            }
+        }
+        Framework::Text err;
+        err.append() << "operation " << (int)op
+                     << " not found in translation table. args: \n";
+        for (auto arg : args)
+        {
+            err.append() << "  " << typeid(*arg).name() << "\n";
+        }
+        throw err.getText();
+    }
+
+    Framework::Assembly::Operation getOperation() const
+    {
+        return op;
+    }
+
+    void encodeModRM_REG(MachineCodeInstruction& result,
+        const Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.needsModRM = true;
+        const Framework::Assembly::GPRegisterArgument* gpRegArg
+            = arg->asGPRegisterArgument();
+        const Framework::Assembly::FPRegisterArgument* fpRegArg
+            = arg->asFPRegisterArgument();
+        if (gpRegArg)
+        {
+            encodeModRM_REG_GP(result, gpRegArg, index);
+        }
+        else if (fpRegArg)
+        {
+            encodeModRM_REG_FP(result, fpRegArg, index);
+        }
+        else
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append()
+                << "Invalid argument type for operand " << index
+                << " for operation " << op << " encoded as MODRM_REG: found "
+                << typeid(*arg).name()
+                << " but expected GPRegisterArgument or FPRegisterArgument";
+            throw err->getText();
+        }
+    }
+
+    void encodeModRM_REG_GP(MachineCodeInstruction& result,
+        const Framework::Assembly::GPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::GPRegister reg = arg->getRegister();
+        if (reg >= Framework::Assembly::R8)
+        {
+            result.needsRex = true;
+            result.exR = 1;
+        }
+        if (arg->getPart() == Framework::Assembly::GPRegisterPart::HIGHER8)
+        {
+            if (reg == Framework::Assembly::RAX)
+            {
+                result.modRM |= 0b100000;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RBX)
+            {
+                result.modRM |= 0b111000;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RCX)
+            {
+                result.modRM |= 0b101000;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RDX)
+            {
+                result.modRM |= 0b110000;
+                result.errIfRex = true;
+            }
+            else
+            {
+                Framework::Text* err = new Framework::Text();
+                err->append() << "Invalid argument for operand " << index
+                              << " for operation " << op
+                              << " HIGHER8 can only be used for registers RAX, "
+                                 "RBX, RCX or RDX";
+            }
+        }
+        else
+        {
+            result.modRM |= (reg & 0b111) << 3;
+        }
+        if (arg->getPart() == Framework::Assembly::GPRegisterPart::LOWER8
+            && (reg == Framework::Assembly::RSP
+                || reg == Framework::Assembly::RBP
+                || reg == Framework::Assembly::RSI
+                || reg == Framework::Assembly::RDI))
+        {
+            result.errIfNoRex = true;
+        }
+    }
+
+    void encodeModRM_REG_FP(MachineCodeInstruction& result,
+        const Framework::Assembly::FPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::FPRegister reg = arg->getRegister();
+        if (reg >= Framework::Assembly::MM8)
+        {
+            result.needsRex = true;
+            result.exR = 1;
+        }
+        result.modRM |= (reg & 0b111) << 3;
+    }
+
+    void encodeModRM_RM(MachineCodeInstruction& result,
+        const Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.needsModRM = true;
+        const Framework::Assembly::GPRegisterArgument* gpRegArg
+            = arg->asGPRegisterArgument();
+        const Framework::Assembly::FPRegisterArgument* fpRegArg
+            = arg->asFPRegisterArgument();
+        const Framework::Assembly::MemoryAccessArgument* memArg
+            = arg->asMemoryAccessArgument();
+        if (gpRegArg)
+        {
+            encodeModRM_RM_GP(result, gpRegArg, index);
+        }
+        else if (fpRegArg)
+        {
+            encodeModRM_RM_FP(result, fpRegArg, index);
+        }
+        else if (memArg)
+        {
+            encodeModRM_RM_Mem(result, memArg, index);
+        }
+        else
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append()
+                << "Invalid argument type for operand " << index
+                << " for operation " << op << " encoded as MODRM_RM: found "
+                << typeid(*arg).name()
+                << " but expected GPRegisterArgument, FPRegisterArgument "
+                   "or MemoryAccessArgument";
+            throw err->getText();
+        }
+    }
+
+    void encodeModRM_RM_GP(MachineCodeInstruction& result,
+        const Framework::Assembly::GPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::GPRegister reg = arg->getRegister();
+        if (reg >= Framework::Assembly::R8)
+        {
+            result.needsRex = true;
+            result.exB = 1;
+        }
+        result.modRM |= 0b11 << 6; // direct register access
+        if (arg->getPart() == Framework::Assembly::GPRegisterPart::HIGHER8)
+        {
+            if (reg == Framework::Assembly::RAX)
+            {
+                result.modRM |= 0b100;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RBX)
+            {
+                result.modRM |= 0b111;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RCX)
+            {
+                result.modRM |= 0b101;
+                result.errIfRex = true;
+            }
+            else if (reg == Framework::Assembly::RDX)
+            {
+                result.modRM |= 0b110;
+                result.errIfRex = true;
+            }
+            else
+            {
+                Framework::Text* err = new Framework::Text();
+                err->append() << "Invalid argument for operand " << index
+                              << " for operation " << op
+                              << " HIGHER8 can only be used for registers RAX, "
+                                 "RBX, RCX or RDX";
+            }
+        }
+        else
+        {
+            result.modRM |= reg & 0b111;
+        }
+        if (arg->getPart() == Framework::Assembly::GPRegisterPart::LOWER8
+            && (reg == Framework::Assembly::RSP
+                || reg == Framework::Assembly::RBP
+                || reg == Framework::Assembly::RSI
+                || reg == Framework::Assembly::RDI))
+        {
+            result.errIfNoRex = true;
+        }
+    }
+
+    void encodeModRM_RM_FP(MachineCodeInstruction& result,
+        const Framework::Assembly::FPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::FPRegister reg = arg->getRegister();
+        if (reg >= Framework::Assembly::MM8)
+        {
+            result.needsRex = true;
+            result.exB = 1;
+        }
+        result.modRM |= 0b11 << 6; // direct register access
+        result.modRM |= reg & 0b111;
+    }
+
+    void encodeModRM_RM_Mem(MachineCodeInstruction& result,
+        const Framework::Assembly::MemoryAccessArgument* arg,
+        int index) const
+    {
+        if (arg->isUsingAddressRegister() || arg->isUsingOffsetRegister())
+        {
+            Framework::Assembly::GPRegister reg = arg->isUsingAddressRegister()
+                                                    ? arg->getAddressRegister()
+                                                    : arg->getOffsetRegister();
+            if (arg->isUsingAddressRegister() && arg->isUsingOffsetRegister())
+            {
+                // SIB needed
+                result.sibNeeded = true;
+                result.modRM |= 0b100 << 3; // indicate SIB
+                if (reg >= Framework::Assembly::R8)
+                {
+                    result.needsRex = true;
+                    result.exB = 1;
+                }
+                result.sib |= reg & 0b111;
+                Framework::Assembly::GPRegister offsetReg
+                    = arg->getOffsetRegister();
+                if (offsetReg == Framework::Assembly::RSP)
+                {
+                    Framework::Text* err = new Framework::Text();
+                    err->append() << "Invalid argument for operand " << index
+                                  << " for operation " << op
+                                  << " RSP can not be used as index register";
+                    throw err->getText();
+                }
+                if (offsetReg >= Framework::Assembly::R8)
+                {
+                    result.needsRex = true;
+                    result.exX = 1;
+                }
+                result.sib |= (offsetReg & 0b111) << 3; // index register
+            }
+            else
+            {
+                if (reg >= Framework::Assembly::R8)
+                {
+                    result.needsRex = true;
+                    result.exB = 1;
+                }
+                result.modRM |= reg & 0b111;
+            }
+            int offset = arg->getOffset();
+            if (offset > 0)
+            {
+                if (offset <= 127 && offset >= -128)
+                {
+                    result.modRM |= 0b01 << 6; // 8 bit displacement
+                    result.disp[0] = (char)offset;
+                    result.dispLength = 1;
+                }
+                else
+                {
+                    result.modRM |= 0b10 << 6; // 32 bit displacement
+                    memcpy(result.disp, &offset, 4);
+                }
+            }
+            else
+            {
+                if ((result.modRM & 0b111) == 0b101)
+                {
+                    // special case: EBP or R13 as
+                    // address register needs disp8=0
+                    result.modRM |= 0b01 << 6; // 8 bit displacement
+                    result.disp[0] = 0;
+                    result.dispLength = 1;
+                }
+            }
+        }
+        else
+        {
+            result.modRM |= 0b100;
+            result.sibNeeded = true;
+            result.sib = 0b00100101; // no base, no index only
+                                     // disp32
+            int offset = arg->getOffset();
+            memcpy(result.disp, &offset, 4);
+            result.dispLength = 4;
+        }
+    }
+
+    void encodeVex_VVVV(MachineCodeInstruction& result,
+        const Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        const Framework::Assembly::FPRegisterArgument* fpRegArg
+            = arg->asFPRegisterArgument();
+        if (fpRegArg)
+        {
+            encodeVex_VVVV_FP(result, fpRegArg, index);
+        }
+        else
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as VEX_VVVV: found "
+                          << typeid(*arg).name()
+                          << " but expected FPRegisterArgument";
+            throw err->getText();
+        }
+    }
+
+    void encodeVex_VVVV_FP(MachineCodeInstruction& result,
+        const Framework::Assembly::FPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::FPRegister reg = arg->getRegister();
+        result.vexVVVV = reg & 0b1111;
+        result.needsVex = true;
+    }
+
+    void encodeOpcode_RD(MachineCodeInstruction& result,
+        const Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        const Framework::Assembly::GPRegisterArgument* gpRegArg
+            = arg->asGPRegisterArgument();
+        if (gpRegArg)
+        {
+            encodeOpcode_RD_GP(result, gpRegArg, index);
+        }
+        else
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as OPCODE_RD: found "
+                          << typeid(*arg).name()
+                          << " but expected GPRegisterArgument";
+            throw err->getText();
+        }
+    }
+
+    void encodeOpcode_RD_GP(MachineCodeInstruction& result,
+        const Framework::Assembly::GPRegisterArgument* arg,
+        int index) const
+    {
+        Framework::Assembly::GPRegister reg = arg->getRegister();
+        if (reg >= Framework::Assembly::R8)
+        {
+            result.needsRex = true;
+            result.exB = 1;
+        }
+        result.opcode[result.opcodeLength - 1] |= reg & 0b111;
+    }
+
+    void encodeIMM8(MachineCodeInstruction& result,
+        Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.immLength = 1;
+        const Framework::Assembly::ConstantArgument* constArg
+            = arg->asConstantArgument();
+        if (constArg == 0)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found " << typeid(*arg).name()
+                          << " but expected ConstantArgument";
+            throw err->getText();
+        }
+        int value = (int)constArg->getValue();
+        int len = (int)constArg->getSize();
+        if (len > 1)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Constant size too large for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found size " << len
+                          << " but expected size BYTE";
+            throw err->getText();
+        }
+        result.imm[0] = (char)(value);
+        result.immLength = 1;
+    }
+
+    void encodeIMM16(MachineCodeInstruction& result,
+        Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.immLength = 1;
+        const Framework::Assembly::ConstantArgument* constArg
+            = arg->asConstantArgument();
+        if (constArg == 0)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found " << typeid(*arg).name()
+                          << " but expected ConstantArgument";
+            throw err->getText();
+        }
+        int value = (int)constArg->getValue();
+        int len = (int)constArg->getSize();
+        if (len > 2)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Constant size too large for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found size " << len
+                          << " but expected size range [BYTE, WORD]";
+            throw err->getText();
+        }
+        short val = (short)(value);
+        memcpy(result.imm, &val, 2);
+        result.immLength = 2;
+    }
+
+    void encodeIMM32(MachineCodeInstruction& result,
+        Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.immLength = 1;
+        const Framework::Assembly::ConstantArgument* constArg
+            = arg->asConstantArgument();
+        if (constArg == 0)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found " << typeid(*arg).name()
+                          << " but expected ConstantArgument";
+            throw err->getText();
+        }
+        int value = (int)constArg->getValue();
+        int len = (int)constArg->getSize();
+        if (len > 4)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Constant size too large for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found size " << len
+                          << " but expected size range [BYTE, DWORD]";
+            throw err->getText();
+        }
+        memcpy(result.imm, &value, 4);
+        result.immLength = 4;
+    }
+
+    void encodeIMM64(MachineCodeInstruction& result,
+        Framework::Assembly::OperationArgument* arg,
+        int index) const
+    {
+        result.immLength = 1;
+        const Framework::Assembly::ConstantArgument* constArg
+            = arg->asConstantArgument();
+        if (constArg == 0)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Invalid argument type for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found " << typeid(*arg).name()
+                          << " but expected ConstantArgument";
+            throw err->getText();
+        }
+        __int64 value = constArg->getValue();
+        int len = (int)constArg->getSize();
+        if (len > 8)
+        {
+            Framework::Text* err = new Framework::Text();
+            err->append() << "Constant size too large for operand " << index
+                          << " for operation " << op
+                          << " encoded as IMM8: found size " << len
+                          << " but expected size range [BYTE, QWORD]";
+            throw err->getText();
+        }
+        memcpy(result.imm, &value, 8);
+        result.immLength = 8;
+    }
+};
+
+class JumpOperationCodeTable : public OperationCodeTable
+{
+private:
+    char opCodeLength;
+    bool inGetEntry;
+
+public:
+    JumpOperationCodeTable(Framework::Assembly::Operation op,
+        char opCodeLength,
+        std::initializer_list<MachineCodeTableEntry> entries)
+        : OperationCodeTable(op, entries),
+          opCodeLength(opCodeLength)
+    {}
+
+    virtual MachineCodeTableEntry& getEntry(
+        const std::vector<Framework::Assembly::OperationArgument*>& args,
+        const Framework::Assembly::AssemblyBlock* codeBlock,
+        const Framework::Assembly::Instruction* current) override
+    {
+        if (inGetEntry)
+        {
+            // recursion can only happen during size calculation so we just
+            // create a dummy const argument for each jump target
+            std::vector<Framework::Assembly::OperationArgument*> newArgs;
+            std::vector<Framework::Assembly::OperationArgument*>
+                transformedArgs;
+            for (Framework::Assembly::OperationArgument* arg : args)
+            {
+                if (arg->asJumpTargetArgument())
+                {
+                    Framework::Assembly::ConstantArgument* constArg
+                        = new Framework::Assembly::ConstantArgument(0);
+                    transformedArgs.push_back(constArg);
+                    newArgs.push_back(constArg);
+                }
+                else
+                {
+                    transformedArgs.push_back(arg);
+                }
+            }
+            MachineCodeTableEntry& result = OperationCodeTable::getEntry(
+                transformedArgs, codeBlock, current);
+            for (Framework::Assembly::OperationArgument* arg : newArgs)
+            {
+                delete arg;
+            }
+            return result;
+        }
+        inGetEntry = 1;
+        std::vector<Framework::Assembly::OperationArgument*> newArgs;
+        std::vector<Framework::Assembly::OperationArgument*> transformedArgs;
+        for (Framework::Assembly::OperationArgument* arg : args)
+        {
+            if (arg->asJumpTargetArgument())
+            {
+                Framework::Text label = arg->asJumpTargetArgument()->getLabel();
+                bool currentFound = false;
+                bool labelFound = false;
+                bool backwords = false;
+                int jumpLength = 0;
+                // search for the label
+                for (const Framework::Assembly::Instruction* instr :
+                    codeBlock->getInstructions())
+                {
+                    if (instr == current)
+                    {
+                        currentFound = true;
+                        if (labelFound)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            backwords = true;
+                        }
+                        continue;
+                    }
+                    if (instr->definesLabel(label))
+                    {
+                        labelFound = true;
+                        if (currentFound)
+                        {
+                            break;
+                        }
+                        continue;
+                    }
+                    if (labelFound || currentFound)
+                    {
+                        jumpLength += instr->compiledSize(codeBlock);
+                    }
+                }
+                if (backwords)
+                {
+                    jumpLength = -jumpLength - 4 - opCodeLength;
+                }
+                Framework::Assembly::ConstantArgument* constArg
+                    = new Framework::Assembly::ConstantArgument(jumpLength);
+                transformedArgs.push_back(constArg);
+                newArgs.push_back(constArg);
+            }
+            else
+            {
+                transformedArgs.push_back(arg);
+            }
+        }
+        MachineCodeTableEntry& result
+            = OperationCodeTable::getEntry(transformedArgs, codeBlock, current);
+        for (Framework::Assembly::OperationArgument* arg : newArgs)
+        {
+            delete arg;
+        }
+        return result;
+    }
+};
+
+thread_local Framework::RCArray<OperationCodeTable>
+    OperationCodeTable::machineCodeTranslationTable;
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isGPRegister(Framework::Assembly::MemoryBlockSize size)
+{
+    return [size](const Framework::Assembly::OperationArgument& arg) {
+        return arg.asGPRegisterArgument() != 0
+            && ((size == Framework::Assembly::MemoryBlockSize::BYTE
+                    && (arg.asGPRegisterArgument()->getPart()
+                            == Framework::Assembly::LOWER8
+                        || arg.asGPRegisterArgument()->getPart()
+                               == Framework::Assembly::HIGHER8))
+                || (size == Framework::Assembly::MemoryBlockSize::WORD
+                    && arg.asGPRegisterArgument()->getPart()
+                           == Framework::Assembly::LOWER16)
+                || (size == Framework::Assembly::MemoryBlockSize::DWORD
+                    && arg.asGPRegisterArgument()->getPart()
+                           == Framework::Assembly::LOWER32)
+                || (size == Framework::Assembly::MemoryBlockSize::QWORD
+                    && arg.asGPRegisterArgument()->getPart()
+                           == Framework::Assembly::FULL64));
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isSpecificGPRegister(Framework::Assembly::GPRegister reg,
+    Framework::Assembly::GPRegisterPart part)
+{
+    return [reg, part](const Framework::Assembly::OperationArgument& arg) {
+        return arg.asGPRegisterArgument() != 0
+            && arg.asGPRegisterArgument()->getRegister() == reg
+            && arg.asGPRegisterArgument()->getPart() == part;
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isGPRegisterOrMemoryAccess(Framework::Assembly::MemoryBlockSize size)
+{
+    return [size](const Framework::Assembly::OperationArgument& arg) {
+        return isGPRegister(size)(arg)
+            || arg.asMemoryAccessArgument()
+                   && arg.asMemoryAccessArgument()->getBlockSize() == size;
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)> isIMM()
+{
+    return [](const Framework::Assembly::OperationArgument& arg) {
+        return arg.asConstantArgument();
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)> isIMM(
+    Framework::Assembly::MemoryBlockSize maxSize)
+{
+    return [maxSize](const Framework::Assembly::OperationArgument& arg) {
+        return arg.asConstantArgument()
+            && arg.asConstantArgument()->getSize() <= maxSize;
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isFPRegister(Framework::Assembly::MemoryBlockSize size)
+{
+    return [size](const Framework::Assembly::OperationArgument& arg) {
+        return arg.asFPRegisterArgument() != 0
+            && ((size == Framework::Assembly::MemoryBlockSize::M128
+                    && arg.asFPRegisterArgument()->getPart()
+                           == Framework::Assembly::X)
+                || (size == Framework::Assembly::MemoryBlockSize::M256
+                    && arg.asFPRegisterArgument()->getPart()
+                           == Framework::Assembly::Y)
+                /*
+                || (size == Framework::Assembly::MemoryBlockSize::M512
+                    && arg.asFPRegisterArgument()->getPart()
+                           == Framework::Assembly::Z)*/);
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isFPRegisterOrMEmoryAccess(Framework::Assembly::MemoryBlockSize size)
+{
+    return [size](const Framework::Assembly::OperationArgument& arg) {
+        return isFPRegister(size)
+            || (arg.asMemoryAccessArgument()
+                && arg.asMemoryAccessArgument()->getBlockSize() == size);
+    };
+}
+
+std::function<bool(const Framework::Assembly::OperationArgument& arg)>
+isFPRegisterOrMEmoryAccess(Framework::Assembly::MemoryBlockSize regSize,
+    Framework::Assembly::MemoryBlockSize memSize)
+{
+    return
+        [regSize, memSize](const Framework::Assembly::OperationArgument& arg) {
+            return isFPRegister(regSize)
+                || (arg.asMemoryAccessArgument()
+                    && arg.asMemoryAccessArgument()->getBlockSize() == memSize);
+        };
+}
+
+void __intializeMachineCodeTranslationTable()
+{
+    if (!OperationCodeTable::machineCodeTranslationTable.getEintragAnzahl())
+    {
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::ADD,
+                {// ADD AL, IMM8
+                    MachineCodeTableEntry(false,
+                        0x04,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(),
+                        IMM8,
+                        READ),
+                    // ADD AX, IMM16
+                    MachineCodeTableEntry(false,
+                        0x05,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(),
+                        IMM16,
+                        READ),
+                    // ADD EAX, IMM32
+                    MachineCodeTableEntry(
+                        false,
+                        0x05,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READWRITE,
+                        [](const Framework::Assembly::OperationArgument& arg) {
+                            return arg.asConstantArgument() != 0;
+                        },
+                        IMM32,
+                        READ),
+                    // ADD RAX, IMM32
+                    MachineCodeTableEntry(true,
+                        0x05,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(),
+                        IMM32,
+                        READ),
+                    // ADD r/m8, IMM8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(),
+                        IMM8,
+                        READ),
+                    // ADD r/m16, IMM8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // ADD r/m32, IMM8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // ADD r/m64, IMM8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // ADD r/m16, IMM16
+                    MachineCodeTableEntry(
+                        false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        [](const Framework::Assembly::OperationArgument& arg) {
+                            return arg.asConstantArgument()
+                                && arg.asConstantArgument()->getSize()
+                                       != Framework::Assembly::MemoryBlockSize::
+                                           BYTE;
+                        },
+                        IMM16,
+                        READ),
+                    // ADD r/m32, IMM32
+                    MachineCodeTableEntry(
+                        false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        [](const Framework::Assembly::OperationArgument& arg) {
+                            return arg.asConstantArgument() != 0
+                                && arg.asConstantArgument()->getSize()
+                                       != Framework::Assembly::MemoryBlockSize::
+                                           BYTE;
+                        },
+                        IMM32,
+                        READ),
+                    // ADD r/m64, IMM32
+                    MachineCodeTableEntry(
+                        true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        [](const Framework::Assembly::OperationArgument& arg) {
+                            return arg.asConstantArgument() != 0
+                                && arg.asConstantArgument()->getSize()
+                                       != Framework::Assembly::MemoryBlockSize::
+                                           BYTE;
+                        },
+                        IMM32,
+                        READ),
+                    // ADD r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x00,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    // ADD r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x01,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    // ADD r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x01,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    // ADD r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x01,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    // ADD r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x02,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // ADD r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x03,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // ADD r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x03,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // ADD r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x03,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::ADDPD,
+                {// ADDPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VADDPD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VADDPD ymm1,ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::ADDPS,
+                {// ADDPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VADDPS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VADDPS ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::ADDSD,
+                {// ADDSD xmm1, xmm2/m64
+                    MachineCodeTableEntry(false,
+                        0x580FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // VADDPS VADDSD xmm1, xmm2, xmm3/m64
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::ADDSS,
+                {// ADDPS xmm1, xmm2/m32
+                    MachineCodeTableEntry(false,
+                        0x580FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // VADDPS VADDSD xmm1, xmm2, xmm3/m64
+                    MachineCodeTableEntry(false,
+                        0x580F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::SUB,
+                {
+                    // SUB AL, imm8
+                    MachineCodeTableEntry(false,
+                        0x2C,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // SUB AX, imm16
+                    MachineCodeTableEntry(false,
+                        0x2D,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // SUB EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0x2D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // SUB RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0x2D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // SUB r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // SUB r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // SUB r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // SUB r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // SUB r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // SUB r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // SUB r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // SUB r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x28,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    // SUB r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x29,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    // SUB r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x29,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    // SUB r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x29,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    // SUB r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x2A,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // SUB r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x2B,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // SUB r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x2B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // SUB SUB r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x2B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::SUBPD,
+                {
+                    // SUBPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5D0F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VSUBPD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VSUBPD ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::SUBPS,
+                {
+                    // SUBPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5D0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VSUBPS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VSUBPS ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::SUBSD,
+                {
+                    // SUBSD xmm1, xmm2/m64
+                    MachineCodeTableEntry(false,
+                        0x5C0FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // VSUBSD xmm1,xmm2, xmm3/m64
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::SUBSS,
+                {
+                    // SUBSS xmm1, xmm2/m32
+                    MachineCodeTableEntry(false,
+                        0x5C0FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // VSUBSD xmm1,xmm2, xmm3/m32
+                    MachineCodeTableEntry(false,
+                        0x5C0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MUL,
+                {
+                    // MUL r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // MUL r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // MUL r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // MUL r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::IMUL,
+                {
+                    // IMUL r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b101,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0xAF0F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0xAF0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0xAF0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // IMUL r16, r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x6B,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // IMUL r32, r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x6B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // IMUL r64, r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x6B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // IMUL r16, r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x69,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // IMUL r32, r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x69,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // IMUL r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x69,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MULPD,
+                {
+                    // MULPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULPD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULPD ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MULPS,
+                {
+                    // MULPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULPS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULPS ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MULSD,
+                {
+                    // MULSD xmm1,xmm2/m64
+                    MachineCodeTableEntry(false,
+                        0x590FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULSD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MULSS,
+                {
+                    // MULSS xmm1,xmm2/m64
+                    MachineCodeTableEntry(false,
+                        0x590FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMULSS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x590F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::DIV,
+                {
+                    // DIV r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // DIV r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // DIV r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // DIV r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::IDIV,
+                {
+                    // IDIV r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        {Framework::Assembly::RAX},
+                        {Framework::Assembly::RAX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // IDIV r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // IDIV r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // IDIV r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {Framework::Assembly::RAX, Framework::Assembly::RDX},
+                        {},
+                        {},
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::DIVPD,
+                {
+                    // DIVPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVPD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVPD ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::DIVPS,
+                {
+                    // DIVPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVPS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVPS ymm1, ymm2, ymm3/m256
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::DIVSD,
+                {
+                    // DIVSD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVSD xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::DIVSS,
+                {
+                    // DIVSS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VDIVSS xmm1,xmm2, xmm3/m128
+                    MachineCodeTableEntry(false,
+                        0x5E0F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::NEG,
+                {
+                    // NEG r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b011,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE),
+                    // NEG r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b011,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // NEG r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b011,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // NEG r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b011,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::INC,
+                {
+                    // INC r/m8
+                    MachineCodeTableEntry(false,
+                        0xFE,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE),
+                    // INC r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // INC r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // INC r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::AND,
+                {
+                    // AND AL, imm8
+                    MachineCodeTableEntry(false,
+                        0x24,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // AND AX, imm16
+                    MachineCodeTableEntry(false,
+                        0x25,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // AND EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0x25,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // AND RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0x25,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // AND r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // AND r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	AND r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	AND r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // AND r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    //	AND r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	AND r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b100,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	AND r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x20,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    //	AND r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x21,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    //	AND r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x21,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    //	AND r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x21,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    //	AND r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x22,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    //	AND r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x23,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    //	AND r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x23,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    //	AND r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x23,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::OR,
+                {
+                    // OR AL, imm8
+                    MachineCodeTableEntry(false,
+                        0x0C,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // OR AX, imm16
+                    MachineCodeTableEntry(false,
+                        0x0D,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // OR EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0x0D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // OR RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0x0D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // OR r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // OR r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	OR r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	OR r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // OR r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    //	OR r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	OR r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b001,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	OR r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x08,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    //	OR r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x09,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    //	OR r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x09,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    //	OR r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x09,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    //	OR r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x0A,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    //	OR r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x0B,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    //	OR r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x0B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    //	OR r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x0B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::XOR,
+                {
+                    // XOR AL, imm8
+                    MachineCodeTableEntry(false,
+                        0x34,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // XOR AX, imm16
+                    MachineCodeTableEntry(false,
+                        0x35,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // XOR EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0x35,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // XOR RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0x35,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // XOR r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // XOR r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	XOR r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    //	XOR r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // XOR r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    //	XOR r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	XOR r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    //	XOR r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x30,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    //	XOR r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x31,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    //	XOR r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x31,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    //	XOR r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x31,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READWRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    //	XOR r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x32,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    //	XOR r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x33,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    //	XOR r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x33,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    //	XOR r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x33,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READWRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::NOT,
+                {
+                    // NOT r/m8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b010,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READWRITE),
+                    // NOT r/m16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b010,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // NOT r/m32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b010,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE),
+                    // NOT r/m64
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b010,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READWRITE),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::TEST,
+                {
+                    // TEST AL, imm8
+                    MachineCodeTableEntry(false,
+                        0xA8,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // TEST AX, imm16
+                    MachineCodeTableEntry(false,
+                        0xA9,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // TEST EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0xA9,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // TEST RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0xA9,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // TEST r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0xF6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // TEST r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // TEST r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // TEST r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0xF7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // TEST r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x84,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    // TEST r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x85,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    // TEST r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x85,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    // TEST r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x85,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CMP,
+                {
+                    // CMP AL, imm8
+                    MachineCodeTableEntry(false,
+                        0x3C,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER8),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // CMP AX, imm16
+                    MachineCodeTableEntry(false,
+                        0x3D,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER16),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // CMP EAX, imm32
+                    MachineCodeTableEntry(false,
+                        0x3D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::LOWER32),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // CMP RAX, imm32
+                    MachineCodeTableEntry(true,
+                        0x3D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isSpecificGPRegister(Framework::Assembly::RAX,
+                            Framework::Assembly::FULL64),
+                        UNDEFINED,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // CMP r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0x80,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // CMP r/m16, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // CMP r/m32, imm8
+                    MachineCodeTableEntry(false,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // CMP r/m64, imm8
+                    MachineCodeTableEntry(true,
+                        0x83,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // CMP r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // CMP r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // TEST r/m64, imm32
+                    MachineCodeTableEntry(true,
+                        0x81,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // CMP r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x38,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b111,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    // CMP r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x39,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    // CMP r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x39,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    // CMP r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x39,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    // CMP r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x3A,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    //	CMP r16, r/m16
+                    MachineCodeTableEntry(false,
+                        0x3B,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    //	CMP r32, r/m32
+                    MachineCodeTableEntry(false,
+                        0x3B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    //	CMP r64, r/m64
+                    MachineCodeTableEntry(true,
+                        0x3B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CMPPD,
+                {
+                    // CMPPD xmm1, xmm2/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPPD xmm1, xmm2, xmm3/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPPD ymm1, ymm2, ymm3/m256, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CMPPS,
+                {
+                    // CMPPS xmm1, xmm2/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPPS xmm1, xmm2, xmm3/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPPS ymm1, ymm2, ymm3/m256, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CMPSD,
+                {
+                    // CMPSD xmm1, xmm2/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPSD xmm1, xmm2, xmm3/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CMPSS,
+                {
+                    // CMPSS xmm1, xmm2/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READWRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // VCMPSS xmm1, xmm2, xmm3/m128, imm8
+                    MachineCodeTableEntry(false,
+                        0xC20F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MOV,
+                {// MOV r/m8, r8
+                    MachineCodeTableEntry(false,
+                        0x88,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        WRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        READ),
+                    // MOV r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x89,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        WRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        READ),
+                    // MOV r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x89,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        READ),
+                    // MOV r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x89,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        READ),
+                    // MOV r8, r/m8
+                    MachineCodeTableEntry(false,
+                        0x8A,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        READ),
+                    // MOV r/m16, r16
+                    MachineCodeTableEntry(false,
+                        0x8B,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // MOV r/m32, r32
+                    MachineCodeTableEntry(false,
+                        0x8B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // MOV r/m64, r64
+                    MachineCodeTableEntry(true,
+                        0x8B,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        WRITE,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // Move imm8 to r8
+                    MachineCodeTableEntry(false,
+                        0xB0,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        OPCODE_RD,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // MOV r16, imm16
+                    MachineCodeTableEntry(false,
+                        0xB8,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        OPCODE_RD,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // MOV r32, imm32
+                    MachineCodeTableEntry(false,
+                        0xB8,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        OPCODE_RD,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // MOV r64, imm64
+                    MachineCodeTableEntry(true,
+                        0xB8,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        OPCODE_RD,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::QWORD),
+                        IMM64,
+                        READ),
+                    // MOV r/m8, imm8
+                    MachineCodeTableEntry(false,
+                        0xC6,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::BYTE),
+                        MODRM_RM,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // MOV r/m16, imm16
+                    MachineCodeTableEntry(false,
+                        0xC7,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // MOV r/m32, imm32
+                    MachineCodeTableEntry(false,
+                        0xC7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // MOV r/m64, imm64
+                    MachineCodeTableEntry(true,
+                        0xC7,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MOVAPD,
+                {
+                    // MOVAPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // MOVAPD xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // MOVAPD xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMOVAPD xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b01,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // MOVAPD ymm1, ymm2/m256
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                    // VMOVAPD ymm2/m256, ymm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b01,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MOVAPS,
+                {
+                    // MOVAPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // MOVAPS xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // VMOVAPS xmm1, xmm2/m128
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                    // VMOVAPS xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b00,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // VMOVAPS ymm1, ymm2/m256
+                    MachineCodeTableEntry(false,
+                        0x280F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b00,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        READ),
+                    // VMOVAPS ymm2/m256, ymm1
+                    MachineCodeTableEntry(false,
+                        0x290F,
+                        (char)2,
+                        false,
+                        true,
+                        true,
+                        0b00,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M256),
+                        MODRM_REG,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MOVSD,
+                {
+                    // MOVSD xmm1, xmm2/m64
+                    MachineCodeTableEntry(false,
+                        0x100FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // MOVSD xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x110FF2,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // VMOVSD VMOVSD xmm1, xmm2, xmm3
+                    MachineCodeTableEntry(false,
+                        0x100F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b11,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::MOVSS,
+                {
+                    // MOVSS xmm1, xmm2/m32
+                    MachineCodeTableEntry(false,
+                        0x100FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_RM,
+                        READ),
+                    // MOVSS xmm2/m128, xmm1
+                    MachineCodeTableEntry(false,
+                        0x110FF3,
+                        (char)3,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isFPRegisterOrMEmoryAccess(
+                            Framework::Assembly::MemoryBlockSize::M128,
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        READ),
+                    // VMOVSS VMOVSD xmm1, xmm2, xmm3
+                    MachineCodeTableEntry(false,
+                        0x100F,
+                        (char)2,
+                        false,
+                        true,
+                        false,
+                        0b10,
+                        0,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_REG,
+                        WRITE,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        VEX_VVVV,
+                        READ,
+                        isFPRegister(
+                            Framework::Assembly::MemoryBlockSize::M128),
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::LEA,
+                {
+                    // LEA r16,m
+                    MachineCodeTableEntry(
+                        false,
+                        0x8D,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_REG,
+                        WRITE,
+                        [](const Framework::Assembly::OperationArgument& p) {
+                            return p.asMemoryAccessArgument();
+                        },
+                        MODRM_RM,
+                        READ),
+                    // LEA r32,m
+                    MachineCodeTableEntry(
+                        false,
+                        0x8D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::DWORD),
+                        MODRM_REG,
+                        WRITE,
+                        [](const Framework::Assembly::OperationArgument& p) {
+                            return p.asMemoryAccessArgument();
+                        },
+                        MODRM_RM,
+                        READ),
+                    // LEA r64,m
+                    MachineCodeTableEntry(
+                        true,
+                        0x8D,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegister(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_REG,
+                        WRITE,
+                        [](const Framework::Assembly::OperationArgument& p) {
+                            return p.asMemoryAccessArgument();
+                        },
+                        MODRM_RM,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JMP,
+                1,
+                {// JMP rel32
+                    MachineCodeTableEntry(false,
+                        0xE9,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JZ,
+                2,
+                {// JZ rel32
+                    MachineCodeTableEntry(false,
+                        0x840F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JNZ,
+                2,
+                {// JNZ rel32
+                    MachineCodeTableEntry(false,
+                        0x850F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JG,
+                2,
+                {// JG rel32
+                    MachineCodeTableEntry(false,
+                        0x8F0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JGE,
+                2,
+                {// JGE rel32
+                    MachineCodeTableEntry(false,
+                        0x8D0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JL,
+                2,
+                {// JL rel32
+                    MachineCodeTableEntry(false,
+                        0x8C0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JLE,
+                2,
+                {// JLE rel32
+                    MachineCodeTableEntry(false,
+                        0x8E0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JA,
+                2,
+                {// JA rel32
+                    MachineCodeTableEntry(false,
+                        0x870F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JC,
+                2,
+                {// JC rel32
+                    MachineCodeTableEntry(false,
+                        0x820F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JNC,
+                2,
+                {// JNC rel32
+                    MachineCodeTableEntry(false,
+                        0x830F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JBE,
+                2,
+                {// JBE rel32
+                    MachineCodeTableEntry(false,
+                        0x860F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JO,
+                2,
+                {// JO rel32
+                    MachineCodeTableEntry(false,
+                        0x800F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JNO,
+                2,
+                {// JNO rel32
+                    MachineCodeTableEntry(false,
+                        0x810F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JP,
+                2,
+                {// JP rel32
+                    MachineCodeTableEntry(false,
+                        0x8A0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JNP,
+                2,
+                {// JNP rel32
+                    MachineCodeTableEntry(false,
+                        0x8B0F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JS,
+                2,
+                {// JS rel32
+                    MachineCodeTableEntry(false,
+                        0x880F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new JumpOperationCodeTable(Framework::Assembly::JNS,
+                2,
+                {// JNS rel32
+                    MachineCodeTableEntry(false,
+                        0x890F,
+                        (char)2,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::CALL,
+                {// CALL rel32
+                    MachineCodeTableEntry(false,
+                        0xE8,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                    // CALL r/m64
+                    MachineCodeTableEntry(false,
+                        0xFF,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b010,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::RET,
+                {// RET
+                    MachineCodeTableEntry(
+                        false, 0xC3, (char)1, false, false, false, 0, 0)}));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::PUSH,
+                {
+                    // PUSH r/m16
+                    MachineCodeTableEntry(false,
+                        0xFF,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // PUSH r/m64
+                    MachineCodeTableEntry(false,
+                        0xFF,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0b110,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                    // PUSH imm8
+                    MachineCodeTableEntry(false,
+                        0x6A,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::BYTE),
+                        IMM8,
+                        READ),
+                    // PUSH imm16
+                    MachineCodeTableEntry(false,
+                        0x68,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::WORD),
+                        IMM16,
+                        READ),
+                    // PUSH imm32
+                    MachineCodeTableEntry(false,
+                        0x68,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isIMM(Framework::Assembly::MemoryBlockSize::DWORD),
+                        IMM32,
+                        READ),
+                }));
+        OperationCodeTable::machineCodeTranslationTable.add(
+            new OperationCodeTable(Framework::Assembly::POP,
+                {
+                    // POP r/m16
+                    MachineCodeTableEntry(false,
+                        0x8F,
+                        (char)1,
+                        true,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::WORD),
+                        MODRM_RM,
+                        READ),
+                    // POP r/m64
+                    MachineCodeTableEntry(false,
+                        0x8F,
+                        (char)1,
+                        false,
+                        false,
+                        false,
+                        0,
+                        0,
+                        isGPRegisterOrMemoryAccess(
+                            Framework::Assembly::MemoryBlockSize::QWORD),
+                        MODRM_RM,
+                        READ),
+                }));
+    }
+}
+
+bool Framework::Assembly::OperationArgument::usesRegister(GPRegister reg) const
+{
+    return false;
+}
+
+bool Framework::Assembly::OperationArgument::usesRegister(FPRegister reg) const
+{
+    return false;
+}
+
+void Framework::Assembly::OperationArgument::replaceRegister(
+    GPRegister oldReg, GPRegister newReg)
+{}
+
+void Framework::Assembly::OperationArgument::replaceRegister(
+    FPRegister oldReg, FPRegister newReg)
+{}
+
+void Framework::Assembly::OperationArgument::addJumpLabelPrefix(
+    Text labelPrefix)
+{}
+
+const Framework::Assembly::GPRegisterArgument*
+Framework::Assembly::OperationArgument::asGPRegisterArgument() const
+{
+    return dynamic_cast<const GPRegisterArgument*>(this);
+}
+
+const Framework::Assembly::MemoryAccessArgument*
+Framework::Assembly::OperationArgument::asMemoryAccessArgument() const
+{
+    return dynamic_cast<const MemoryAccessArgument*>(this);
+}
+
+const Framework::Assembly::ConstantArgument*
+Framework::Assembly::OperationArgument::asConstantArgument() const
+{
+    return dynamic_cast<const ConstantArgument*>(this);
+}
+
+const Framework::Assembly::FPRegisterArgument*
+Framework::Assembly::OperationArgument::asFPRegisterArgument() const
+{
+    return dynamic_cast<const FPRegisterArgument*>(this);
+}
+
+const Framework::Assembly::JumpTargetArgument*
+Framework::Assembly::OperationArgument::asJumpTargetArgument() const
+{
+    return dynamic_cast<const JumpTargetArgument*>(this);
+}
+
+Framework::Assembly::GPRegisterArgument::GPRegisterArgument(
+    GPRegister reg, GPRegisterPart part)
+    : reg(reg),
+      part(part)
+{}
+
+bool Framework::Assembly::GPRegisterArgument::usesRegister(GPRegister reg) const
+{
+    return this->reg == reg;
+}
+
+void Framework::Assembly::GPRegisterArgument::replaceRegister(
+    GPRegister oldReg, GPRegister newReg)
+{
+    if (reg == oldReg)
+    {
+        reg = newReg;
+    }
+}
+
+Framework::Assembly::GPRegister
+Framework::Assembly::GPRegisterArgument::getRegister() const
+{
+    return reg;
+}
+
+Framework::Assembly::GPRegisterPart
+Framework::Assembly::GPRegisterArgument::getPart() const
+{
+    return part;
+}
+
+Framework::Assembly::FPRegisterArgument::FPRegisterArgument(
+    FPRegister reg, FPRegisterPart part)
+    : reg(reg),
+      part(part)
+{}
+
+bool Framework::Assembly::FPRegisterArgument::usesRegister(FPRegister reg) const
+{
+    return this->reg == reg;
+}
+
+void Framework::Assembly::FPRegisterArgument::replaceRegister(
+    FPRegister oldReg, FPRegister newReg)
+{
+    if (reg == oldReg)
+    {
+        reg = newReg;
+    }
+}
+
+Framework::Assembly::FPRegister
+Framework::Assembly::FPRegisterArgument::getRegister() const
+{
+    return reg;
+}
+
+Framework::Assembly::FPRegisterPart
+Framework::Assembly::FPRegisterArgument::getPart() const
+{
+    return part;
+}
+
+Framework::Assembly::MemoryAccessArgument::MemoryAccessArgument(
+    MemoryBlockSize blockSize,
+    GPRegister address,
+    bool useAddressReg,
+    int offset,
+    bool useOffsetReg,
+    GPRegister offsetReg)
+    : blockSize(blockSize),
+      useAddressReg(useAddressReg),
+      address(address),
+      offset(offset),
+      offsetReg(offsetReg),
+      useOffsetReg(useOffsetReg)
+{}
+
+bool Framework::Assembly::MemoryAccessArgument::usesRegister(
+    GPRegister reg) const
+{
+    return (useAddressReg && this->address == reg)
+        || (useOffsetReg && offsetReg == reg);
+}
+
+void Framework::Assembly::MemoryAccessArgument::replaceRegister(
+    GPRegister oldReg, GPRegister newReg)
+{
+    if (useAddressReg && address == oldReg)
+    {
+        address = newReg;
+    }
+    if (useOffsetReg && offsetReg == oldReg)
+    {
+        offsetReg = newReg;
+    }
+}
+
+bool Framework::Assembly::MemoryAccessArgument::isUsingAddressRegister() const
+{
+    return useAddressReg;
+}
+
+Framework::Assembly::GPRegister
+Framework::Assembly::MemoryAccessArgument::getAddressRegister() const
+{
+    return address;
+}
+
+int Framework::Assembly::MemoryAccessArgument::getOffset() const
+{
+    return offset;
+}
+
+bool Framework::Assembly::MemoryAccessArgument::isUsingOffsetRegister() const
+{
+    return useOffsetReg;
+}
+
+Framework::Assembly::GPRegister
+Framework::Assembly::MemoryAccessArgument::getOffsetRegister() const
+{
+    return offsetReg;
+}
+
+Framework::Assembly::MemoryBlockSize
+Framework::Assembly::MemoryAccessArgument::getBlockSize() const
+{
+    return blockSize;
+}
+
+Framework::Assembly::ConstantArgument::ConstantArgument(
+    __int64 value, MemoryBlockSize size)
+    : value(value),
+      size(size)
+{}
+
+Framework::Assembly::ConstantArgument::ConstantArgument(
+    int value, MemoryBlockSize size)
+    : value((__int64)value),
+      size(size)
+{}
+
+Framework::Assembly::ConstantArgument::ConstantArgument(
+    short value, MemoryBlockSize size)
+    : value((__int64)value),
+      size(size)
+{}
+
+Framework::Assembly::ConstantArgument::ConstantArgument(
+    char value, MemoryBlockSize size)
+    : value((__int64)value),
+      size(size)
+{}
+
+__int64 Framework::Assembly::ConstantArgument::getValue() const
+{
+    return value;
+}
+
+Framework::Assembly::MemoryBlockSize
+Framework::Assembly::ConstantArgument::getSize() const
+{
+    return size;
+}
+
+Framework::Assembly::JumpTargetArgument::JumpTargetArgument(Text name)
+    : name(name)
+{}
+
+void Framework::Assembly::JumpTargetArgument::addJumpLabelPrefix(
+    Text labelPrefix)
+{
+    name = labelPrefix + name;
+}
+
+const Framework::Text& Framework::Assembly::JumpTargetArgument::getLabel() const
+{
+    return name;
+}
+
+Framework::Assembly::Instruction::Instruction(
+    Operation op, std::initializer_list<OperationArgument*> args)
+    : ReferenceCounter(),
+      op(op),
+      args(args)
+{}
+
+Framework::Assembly::Instruction::~Instruction()
+{
+    for (auto arg : args)
+    {
+        delete arg;
+    }
+}
+
+bool Framework::Assembly::Instruction::writesToRegister(
+    GPRegister reg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (GPRegister r : entry.getImpliedWriteGPRegs())
+            {
+                if (r == reg)
+                {
+                    return 1;
+                }
+            }
+            int index = 0;
+            for (const OperationArgument* arg : args)
+            {
+                OperandRW rw = entry.getOperandRW(index);
+                if (rw == WRITE || rw == READWRITE)
+                {
+                    if (arg->asGPRegisterArgument()
+                        && arg->asGPRegisterArgument()->getRegister() == reg)
+                    {
+                        return 1;
+                    }
+                }
+                index++;
+            }
+        }
+    }
+    return 0;
+}
+
+bool Framework::Assembly::Instruction::writesToRegister(
+    FPRegister reg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (FPRegister r : entry.getImpliedWriteFPRegs())
+            {
+                if (r == reg)
+                {
+                    return 1;
+                }
+            }
+            int index = 0;
+            for (const OperationArgument* arg : args)
+            {
+                OperandRW rw = entry.getOperandRW(index);
+                if (rw == WRITE || rw == READWRITE)
+                {
+                    if (arg->asFPRegisterArgument()
+                        && arg->asFPRegisterArgument()->getRegister() == reg)
+                    {
+                        return 1;
+                    }
+                }
+                index++;
+            }
+        }
+    }
+    return 0;
+}
+
+bool Framework::Assembly::Instruction::readsFromRegister(
+    GPRegister reg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            const MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (GPRegister r : entry.getImpliedReadGPRegs())
+            {
+                if (r == reg)
+                {
+                    return 1;
+                }
+            }
+            int index = 0;
+            for (const OperationArgument* arg : args)
+            {
+                OperandRW rw = entry.getOperandRW(index);
+                if (rw == READ || rw == READWRITE)
+                {
+                    if (arg->asGPRegisterArgument()
+                        && arg->asGPRegisterArgument()->getRegister() == reg)
+                    {
+                        return 1;
+                    }
+                }
+                if (arg->asMemoryAccessArgument()
+                    && arg->asMemoryAccessArgument()->usesRegister(reg))
+                {
+                    return 1;
+                }
+                index++;
+            }
+        }
+    }
+    return 0;
+}
+
+bool Framework::Assembly::Instruction::readsFromRegister(
+    FPRegister reg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (FPRegister r : entry.getImpliedReadFPRegs())
+            {
+                if (r == reg)
+                {
+                    return 1;
+                }
+            }
+            int index = 0;
+            for (const OperationArgument* arg : args)
+            {
+                OperandRW rw = entry.getOperandRW(index);
+                if (rw == READ || rw == READWRITE)
+                {
+                    if (arg->asFPRegisterArgument()
+                        && arg->asFPRegisterArgument()->getRegister() == reg)
+                    {
+                        return 1;
+                    }
+                }
+                index++;
+            }
+        }
+    }
+    return 0;
+}
+
+bool Framework::Assembly::Instruction::isReplacementPossible(
+    GPRegister oldReg, GPRegister newReg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (GPRegister r : entry.getImpliedReadGPRegs())
+            {
+                if (r == oldReg)
+                {
+                    return 0;
+                }
+            }
+            for (GPRegister r : entry.getImpliedWriteGPRegs())
+            {
+                if (r == oldReg)
+                {
+                    return 0;
+                }
+            }
+        }
+    }
+    if (newReg == RBP || newReg == RSI || newReg == RDI)
+    {
+        if (oldReg == RBP || oldReg == RSI || oldReg == RDI)
+        {
+            return 1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+    if (newReg >= R8)
+    {
+        return oldReg >= R8;
+    }
+    return oldReg < R8;
+}
+
+bool Framework::Assembly::Instruction::isReplacementPossible(
+    FPRegister oldReg, FPRegister newReg, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeTableEntry& entry
+                = tableEntry->getEntry(args, block, this);
+            for (FPRegister r : entry.getImpliedReadFPRegs())
+            {
+                if (r == oldReg)
+                {
+                    return 0;
+                }
+            }
+            for (FPRegister r : entry.getImpliedWriteFPRegs())
+            {
+                if (r == oldReg)
+                {
+                    return 0;
+                }
+            }
+        }
+    }
+    return 1;
+}
+
+void Framework::Assembly::Instruction::replaceRegister(
+    GPRegister oldReg, GPRegister newReg)
+{
+    for (auto arg : args)
+    {
+        arg->replaceRegister(oldReg, newReg);
+    }
+}
+
+void Framework::Assembly::Instruction::replaceRegister(
+    FPRegister oldReg, FPRegister newReg)
+{
+    for (auto arg : args)
+    {
+        arg->replaceRegister(oldReg, newReg);
+    }
+}
+
+void Framework::Assembly::Instruction::addJumpLabelPrefix(Text labelPrefix)
+{
+    for (auto arg : args)
+    {
+        arg->addJumpLabelPrefix(labelPrefix);
+    }
+}
+
+void Framework::Assembly::Instruction::compile(
+    StreamWriter* byteCodeWriter, const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeInstruction instr
+                = tableEntry->getInstruction(args, block, this);
+            instr.write(*byteCodeWriter);
+            return;
+        }
+    }
+    Text err;
+    err.append() << "Failed to compile instruction: operation code " << (int)op
+                 << " not found in translation table. args: \n";
+    for (auto arg : args)
+    {
+        err.append() << "  " << typeid(*arg).name() << "\n";
+    }
+    throw err.getText();
+}
+
+int Framework::Assembly::Instruction::compiledSize(
+    const AssemblyBlock* block) const
+{
+    __intializeMachineCodeTranslationTable();
+    for (OperationCodeTable* tableEntry :
+        OperationCodeTable::machineCodeTranslationTable)
+    {
+        if (tableEntry->getOperation() == op)
+        {
+            MachineCodeInstruction instr
+                = tableEntry->getInstruction(args, block, this);
+            return instr.calculateSize();
+        }
+    }
+    return 0;
+}
+
+Framework::Assembly::Operation
+Framework::Assembly::Instruction::getOperation() const
+{
+    return op;
+}
+
+bool Framework::Assembly::Instruction::definesLabel(Text label) const
+{
+    return op == NOP && args.size() == 1 && args.at(0)->asJumpTargetArgument()
+        && args.at(0)->asJumpTargetArgument()->getLabel().istGleich(label);
+}
+
+Framework::Assembly::AssemblyBlock::AssemblyBlock()
+    : inlineIndex(0),
+      compiledCode(0)
+{}
+
+Framework::Assembly::AssemblyBlock::~AssemblyBlock()
+{
+    if (compiledCode != 0)
+    {
+        // Free the compiled code memory
+        VirtualFree(compiledCode, 0, MEM_RELEASE);
+    }
+}
+
+void Framework::Assembly::AssemblyBlock::addInstruction(Instruction* instr)
+{
+    instructions.add(instr);
+}
+
+void Framework::Assembly::AssemblyBlock::defineJumpTarget(Text name)
+{
+    instructions.add(new Instruction(NOP, {new JumpTargetArgument(name)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addJump(
+    Operation jumpOp, Text targetName)
+{
+    instructions.add(
+        new Instruction(jumpOp, {new JumpTargetArgument(targetName)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    char* valueAddress, GPRegister target)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target, LOWER8),
+            new MemoryAccessArgument(MemoryBlockSize::BYTE, target)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    short* valueAddress, GPRegister target)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target, LOWER16),
+            new MemoryAccessArgument(MemoryBlockSize::WORD, target)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    int* valueAddress, GPRegister target)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target, LOWER32),
+            new MemoryAccessArgument(MemoryBlockSize::DWORD, target)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    __int64* valueAddress, GPRegister target)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(target),
+            new MemoryAccessArgument(MemoryBlockSize::QWORD, target)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    float* valueAddress, FPRegister target, GPRegister temp)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(temp),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOVSS,
+        {new FPRegisterArgument(target),
+            new MemoryAccessArgument(MemoryBlockSize::DWORD, temp)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addLoadValue(
+    double* valueAddress, FPRegister target, GPRegister temp)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(temp),
+            new ConstantArgument(reinterpret_cast<__int64>(valueAddress))}));
+    instructions.add(new Instruction(MOVSD,
+        {new FPRegisterArgument(target),
+            new MemoryAccessArgument(MemoryBlockSize::QWORD, temp)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addCall(
+    void* functionAddress, GPRegister temp)
+{
+    instructions.add(new Instruction(MOV,
+        {new GPRegisterArgument(temp),
+            new ConstantArgument(reinterpret_cast<__int64>(functionAddress))}));
+    instructions.add(new Instruction(
+        CALL, {new MemoryAccessArgument(MemoryBlockSize::QWORD, temp)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addReturn()
+{
+    instructions.add(new Instruction(RET, {}));
+}
+
+void Framework::Assembly::AssemblyBlock::addPush(
+    GPRegister reg, GPRegisterPart part)
+{
+    instructions.add(
+        new Instruction(PUSH, {new GPRegisterArgument(reg, part)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addPop(
+    GPRegister reg, GPRegisterPart part)
+{
+    instructions.add(new Instruction(POP, {new GPRegisterArgument(reg, part)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addPush(
+    FPRegister reg, FPRegisterPart part)
+{
+    instructions.add(new Instruction(SUB,
+        {new GPRegisterArgument(RSP),
+            new ConstantArgument(part == X ? 16 : 32)}));
+    instructions.add(new Instruction(MOVAPD,
+        {new MemoryAccessArgument(
+             part == X ? MemoryBlockSize::M128 : MemoryBlockSize::M256, RSP),
+            new FPRegisterArgument(reg, part)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addPop(
+    FPRegister reg, FPRegisterPart part)
+{
+    instructions.add(new Instruction(MOVAPD,
+        {new FPRegisterArgument(reg, part),
+            new MemoryAccessArgument(
+                part == X ? MemoryBlockSize::M128 : MemoryBlockSize::M256,
+                RSP)}));
+    instructions.add(new Instruction(ADD,
+        {new GPRegisterArgument(RSP),
+            new ConstantArgument(part == X ? 16 : 32)}));
+}
+
+void Framework::Assembly::AssemblyBlock::addBlock(AssemblyBlock* block,
+    std::initializer_list<GPRegister> preservedGPRegisters,
+    std::initializer_list<FPRegister> preservedFPRegisters,
+    GPRegister* blockResultGpReg,
+    FPRegister* blockResultFpReg)
+{
+    RCArray<Instruction> tempInstructions;
+    for (GPRegister preservedReg : preservedGPRegisters)
+    {
+        if (block->writesToRegister(preservedReg))
+        {
+            bool replaced = false;
+            for (int i = 0; i < 16; i++)
+            {
+                if (i == 4)
+                {
+                    continue; // Skip RSP (stack counter register)
+                }
+                bool found = false;
+                for (GPRegister r : preservedGPRegisters)
+                {
+                    if (r == (GPRegister)i)
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                {
+                    continue;
+                }
+                GPRegister newReg = (GPRegister)i;
+                if (!block->writesToRegister(newReg)
+                    && !block->readsFromRegister(newReg)
+                    && block->isReplacementPossible(preservedReg, newReg))
+                {
+                    if (preservedReg == RAX)
+                    {
+                        *blockResultGpReg = newReg;
+                    }
+                    replaced = true;
+                    block->replaceRegister(preservedReg, newReg);
+                    break;
+                }
+            }
+            if (!replaced)
+            {
+                addPush(preservedReg);
+                tempInstructions.add(
+                    new Instruction(
+                        POP, {new GPRegisterArgument(preservedReg)}),
+                    0);
+            }
+        }
+    }
+    for (FPRegister preservedReg : preservedFPRegisters)
+    {
+        if (block->writesToRegister(preservedReg))
+        {
+            bool replaced = false;
+            for (int i = 0; i < __FP_REGISTER_COUNT; i++)
+            {
+                bool found = false;
+                for (FPRegister r : preservedFPRegisters)
+                {
+                    if (r == (FPRegister)i)
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                {
+                    continue;
+                }
+                FPRegister newReg = (FPRegister)i;
+                if (!block->writesToRegister(newReg)
+                    && !block->readsFromRegister(newReg)
+                    && block->isReplacementPossible(preservedReg, newReg))
+                {
+                    if (preservedReg == MM0)
+                    {
+                        *blockResultFpReg = newReg;
+                    }
+                    replaced = true;
+                    block->replaceRegister(preservedReg, newReg);
+                    break;
+                }
+            }
+            if (!replaced)
+            {
+                addPush(preservedReg);
+                tempInstructions.add(new Instruction(MOVAPD,
+                    {new FPRegisterArgument(preservedReg, Y),
+                        new MemoryAccessArgument(MemoryBlockSize::M256, RSP)}));
+                tempInstructions.add(new Instruction(ADD,
+                    {new GPRegisterArgument(RSP), new ConstantArgument(32)}));
+            }
+        }
+    }
+    int index = 0;
+    Text prefix = "inlined_";
+    prefix.append() << inlineIndex << "_";
+    block->addJumpLabelPrefix(prefix);
+    bool returnFound = false;
+    for (const auto& instr : block->instructions)
+    {
+        if (instr->getOperation() == RET)
+        {
+            if (index != block->instructions.getEintragAnzahl() - 1)
+            {
+                returnFound = true;
+                instructions.add(new Instruction(
+                    JMP, {new JumpTargetArgument(Text("after_") + prefix)}));
+            }
+        }
+        else
+        {
+            instructions.add(dynamic_cast<Instruction*>(instr->getThis()));
+        }
+        index++;
+    }
+    if (returnFound)
+    {
+        defineJumpTarget(Text("after_") + prefix);
+    }
+    for (const auto& instr : tempInstructions)
+    {
+        instructions.add(dynamic_cast<Instruction*>(instr->getThis()));
+    }
+}
+
+bool Framework::Assembly::AssemblyBlock::writesToRegister(GPRegister reg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (instr->writesToRegister(reg, this))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Framework::Assembly::AssemblyBlock::writesToRegister(FPRegister reg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (instr->writesToRegister(reg, this))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Framework::Assembly::AssemblyBlock::readsFromRegister(GPRegister reg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (instr->readsFromRegister(reg, this))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Framework::Assembly::AssemblyBlock::readsFromRegister(FPRegister reg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (instr->readsFromRegister(reg, this))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Framework::Assembly::AssemblyBlock::isReplacementPossible(
+    GPRegister oldReg, GPRegister newReg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (!instr->isReplacementPossible(oldReg, newReg, this))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool Framework::Assembly::AssemblyBlock::isReplacementPossible(
+    FPRegister oldReg, FPRegister newReg) const
+{
+    for (const auto& instr : instructions)
+    {
+        if (!instr->isReplacementPossible(oldReg, newReg, this))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+void Framework::Assembly::AssemblyBlock::replaceRegister(
+    GPRegister oldReg, GPRegister newReg)
+{
+    for (const auto& instr : instructions)
+    {
+        instr->replaceRegister(oldReg, newReg);
+    }
+}
+
+void Framework::Assembly::AssemblyBlock::replaceRegister(
+    FPRegister oldReg, FPRegister newReg)
+{
+    for (const auto& instr : instructions)
+    {
+        instr->replaceRegister(oldReg, newReg);
+    }
+}
+
+void Framework::Assembly::AssemblyBlock::addJumpLabelPrefix(Text labelPrefix)
+{
+    for (const auto& instr : instructions)
+    {
+        instr->addJumpLabelPrefix(labelPrefix);
+    }
+}
+
+const Framework::RCArray<Framework::Assembly::Instruction>&
+Framework::Assembly::AssemblyBlock::getInstructions() const
+{
+    return instructions;
+}
+
+void* Framework::Assembly::AssemblyBlock::compile()
+{
+    if (compiledCode != 0)
+    {
+        return compiledCode;
+    }
+    InMemoryBuffer buffer;
+    int index = 0;
+    // check non-volatile registers
+    RCArray<Instruction> restoreInstructions;
+    for (GPRegister nvReg : {RBX, RBP, RSI, RDI, R12, R13, R14, R15})
+    {
+        if (writesToRegister(nvReg))
+        {
+            Instruction pushInstr(
+                PUSH, {new GPRegisterArgument(nvReg, FULL64)});
+            pushInstr.compile(&buffer, this);
+            restoreInstructions.add(
+                new Instruction(POP, {new GPRegisterArgument(nvReg, FULL64)}),
+                0);
+        }
+    }
+    for (FPRegister nvReg :
+        {MM6, MM7, MM8, MM9, MM10, MM11, MM12, MM13, MM14, MM15})
+    {
+        if (writesToRegister(nvReg))
+        {
+            Instruction subInst(
+                SUB, {new GPRegisterArgument(RSP), new ConstantArgument(32)});
+            subInst.compile(&buffer, this);
+            Instruction pushInstr(MOVAPD,
+                {new MemoryAccessArgument(MemoryBlockSize::M256, RSP),
+                    new FPRegisterArgument(nvReg, Y)});
+            pushInstr.compile(&buffer, this);
+            restoreInstructions.add(new Instruction(MOVAPD,
+                {new FPRegisterArgument(nvReg, Y),
+                    new MemoryAccessArgument(MemoryBlockSize::M256, RSP)}));
+            restoreInstructions.add(new Instruction(
+                ADD, {new GPRegisterArgument(RSP), new ConstantArgument(32)}));
+        }
+    }
+    // replace return instructions with jumps to the end
+    if (restoreInstructions.getEintragAnzahl() > 0)
+    {
+        bool needed = false;
+        for (int index = 0; index < instructions.getEintragAnzahl(); index++)
+        {
+            if (instructions.z(index)->getOperation() == RET)
+            {
+                if (index < instructions.getEintragAnzahl() - 1)
+                {
+                    needed = true;
+                    instructions.set(
+                        new Instruction(JMP,
+                            {new JumpTargetArgument(
+                                Text("_restore_non_volatile_registers"))}),
+                        index);
+                }
+                else
+                {
+                    // remove last RET instruction, will be added after non
+                    // volatile registers were restored from the stack
+                    instructions.remove(index);
+                }
+            }
+        }
+        if (needed)
+        {
+            defineJumpTarget(Text("_restore_non_volatile_registers"));
+        }
+    }
+    // compile instructions
+    for (const auto& instr : instructions)
+    {
+        instr->compile(&buffer, this);
+    }
+    // restore non-volatile registers
+    for (const auto& instr : restoreInstructions)
+    {
+        instr->compile(&buffer, this);
+    }
+    // add final RET instruction
+    if (instructions.z(instructions.getLastIndex())->getOperation() != RET)
+    {
+        Instruction retInstr(RET, {});
+        retInstr.compile(&buffer, this);
+    }
+    int totalSize = (int)buffer.getSize();
+    // Allocate executable memory
+    compiledCode = VirtualAlloc(nullptr, totalSize, MEM_COMMIT, PAGE_READWRITE);
+    if (compiledCode == nullptr)
+    {
+        throw std::runtime_error("Failed to allocate executable memory.");
+    }
+    // Write the compiled code into the allocated memory
+    buffer.lese((char*)compiledCode, totalSize);
+    DWORD dummy;
+    VirtualProtect(compiledCode, totalSize, PAGE_EXECUTE_READ, &dummy);
+    return compiledCode;
+}

Assembly.h

@@ -0,0 +1,819 @@
+#pragma once
+
+#include <vector>
+
+#include "Array.h"
+#include "Text.h"
+#include "Writer.h"
+
+namespace Framework
+{
+    namespace Assembly
+    {
+        enum Operation
+        {
+            // no real operation, used for labels
+            NOP,
+
+            // Arithmetic Operations
+
+            ADD,   // Addition
+            ADDPD, // Add Packed Double-Precision Floating-Point Values
+            ADDPS, // Add Packed Single-Precision Floating-Point Values
+            ADDSD, // Add Scalar Double-Precision Floating-Point Values
+            ADDSS, // Add Scalar Single-Precision Floating-Point Values
+            SUB,   // Subtraction
+            SUBPD, // Subtract Packed Double-Precision Floating-Point Values
+            SUBPS, // Subtract Packed Single-Precision Floating-Point Values
+            SUBSD, // Subtract Scalar Double-Precision Floating-Point Values
+            SUBSS, // Subtract Scalar Single-Precision Floating-Point Values
+            MUL,   // Multiply unsigned
+            IMUL,  // Multiply signed
+            MULPD, // Multiply Packed Double Precision Floating-Point Values
+            MULPS, // Multiply Packed Single Precision Floating-Point Values
+            MULSD, // Multiply Scalar Double Precision Floating-Point Value
+            MULSS, // Multiply Scalar Single Precision Floating-Point Values
+            DIV,   // Division unsigned
+            IDIV,  // Division signed
+            DIVPD, // Divide Packed Double-Precision Floating-Point Values
+            DIVPS, // Divide Packed Single-Precision Floating-Point Values
+            DIVSD, // Divide Scalar Double-Precision Floating-Point Values
+            DIVSS, // Divide Scalar Single-Precision Floating-Point Values
+            NEG,   // Negation
+            INC,   // Increment
+
+            // Logical Operations
+
+            AND, // Bitwise AND
+            OR,  // Bitwise OR
+            XOR, // Bitwise XOR
+            NOT, // Bitwise NOT
+
+            // Comparison Operations
+
+            // Bitwise AND without storing the result. only
+            // SpecialRegister.FLAGS (SF, ZF, PF) is affected
+            TEST,
+            // Compare
+            // temporary subtracts op2 from op without storing the result. only
+            // SpecialRegister.FLAGS is affected
+            CMP,
+            // Compare Packed Double Precision Floating-Point Values
+            // temporary subtracts op2 from op without storing the result. only
+            // SpecialRegister.FLAGS is affected
+            CMPPD,
+            // Compare Packed Single Precision Floating-Point Values
+            // temporary subtracts op2 from op without storing the result. only
+            // SpecialRegister.FLAGS is affected
+            CMPPS,
+            // Compare Scalar Double Precision Floating-Point Value
+            // temporary subtracts op2 from op without storing the result. only
+            // SpecialRegister.FLAGS is affected
+            CMPSD,
+            // Compare Scalar Single Precision Floating-Point Value
+            // temporary subtracts op2 from op without storing the result. only
+            // SpecialRegister.FLAGS is affected
+            CMPSS,
+
+            // Data Movement
+
+            MOV, // Move data from source to destination
+            // Move Aligned Packed Double-Precision Floating-Point Value
+            MOVAPD,
+            // Move Aligned Packed Single-Precision Floating-Point Value
+            MOVAPS,
+            MOVSD, // Move Scalar Double-Precision Floating-Point Value
+            MOVSS, // Move Scalar Single-Precision Floating-Point Value
+            LEA,   // Load Effective Address
+
+            // Control Flow
+
+            JMP, // Unconditional Jump
+            JZ,  // Jump if Zero: SpecialRegister.FLAGS(ZF) = 1
+            JNZ, // Jump if Not Zero: SpecialRegister.FLAGS(ZF) = 0
+            // Jump if Greater: SpecialRegister.FLAGS(SF) =
+            // SpecialRegister.FLAGS(OF) and SpecialRegister.FLAGS(ZF) = 0
+            JG,
+            // Jump if Greater or Equal: SpecialRegister.FLAGS(SF) =
+            // SpecialRegister.FLAGS(OF)
+            JGE,
+            // Jump if Less: SpecialRegister.FLAGS(SF) !=
+            // SpecialRegister.FLAGS(OF)
+            JL,
+            // Jump if Less or Equal: SpecialRegister.FLAGS(SF) !=
+            // SpecialRegister.FLAGS(OF) or SpecialRegister.FLAGS(ZF) = 1
+            JLE,
+            // Jump if above: SpecialRegister.FLAGS(CF) = 0 and
+            // SpecialRegister.FLAGS(ZF) = 0
+            JA,
+            // Jump if carry: SpecialRegister.FLAGS(CF) = 1
+            JC,
+            // Jump if not carry: SpecialRegister.FLAGS(CF) = 0
+            JNC,
+            // Jump if below or equal: SpecialRegister.FLAGS(CF) = 1 or
+            // SpecialRegister.FLAGS(ZF) = 1
+            JBE,
+            JO,   // Jump if overflow: SpecialRegister.FLAGS(OF) = 1
+            JNO,  // Jump if not overflow: SpecialRegister.FLAGS(OF) = 0
+            JP,   // Jump if parity even: SpecialRegister.FLAGS(PF) = 1
+            JNP,  // Jump if not parity odd: SpecialRegister.FLAGS(PF) = 0
+            JS,   // Jump if sign: SpecialRegister.FLAGS(SF) = 1
+            JNS,  // Jump if not sign: SpecialRegister.FLAGS(SF) = 0
+            CALL, // Call subroutine
+            RET,  // Return from subroutine
+
+            // Stack Operations
+
+            PUSH, // Push onto stack
+            POP   // Pop from stack
+        };
+
+        enum CMP_IMM8
+        {
+            EQ_OQ = 0,     // Equal (ordered, non-signaling)
+            LT_OS = 1,     // Less than (ordered, signaling)
+            LE_OS = 2,     // Less than or equal (ordered, signaling
+            UNORD_Q = 3,   // Unordered (non-signaling)
+            NEQ_UQ = 4,    // Not-equal (unordered, non-signaling)
+            NLT_US = 5,    // Not less than (unordered, signaling)
+            NLE_US = 6,    // Not-less-than-or-equal (unordered, signaling)
+            ORD_Q = 7,     // Ordered (non-signaling)
+            EQ_US = 8,     // Equal (unordered, signaling)
+            NGE_US = 9,    // Not-greater-than-or-equal (unordered, signaling)
+            NGT_US = 10,   // Not-greater-than (unordered, signaling)
+            FALSE_OQ = 11, // False (ordered, non-signaling)
+            NEQ_OQ = 12,   // Not-equal (ordered, non-signaling)
+            GE_OS = 13,    // Greater-than-or-equal (ordered, signaling)
+            GT_OS = 14,    // Greater-than (ordered, signaling)
+            TRUE_UQ = 15,  // True (unordered, non-signaling)
+            EQ_OS = 16,    // Equal (ordered, signaling)
+            LT_OQ = 17,    // Less-than (ordered, non-signaling)
+            LE_OQ = 18,    // Less-than-or-equal (ordered, non
+            UNORD_S = 19,  // Unordered (signaling)
+            NEQ_US = 20,   // Not-equal (unordered, signaling)
+            NLT_UQ = 21,   // Not-less-than (unordered, non-sign
+            NLE_UQ = 22,   // Not-less-than-or-equal (unordered, non-signaling)
+            ORD_S = 23,    // Ordered (signaling)
+            EQ_UQ = 24,    // Equal (unordered, non-signaling)
+            NGE_UQ = 25,   // Not-greater-than-or-equal (
+            NGT_UQ = 26,   // Not-greater-than (unordered, non-signaling)
+            FALSE_OS = 27, // False (ordered, signaling)
+            NEQ_OS = 28,   // Not-equal (ordered, signaling)
+            GE_OQ = 29,    // Greater-than-or-equal (ordered, non
+            GT_OQ = 30,    // Greater-than (ordered, non-signaling)
+            TRUE_S = 31    // True (signaling)
+        };
+
+        // General Purpose Registers
+        enum GPRegister
+        {
+            // volatile register (can be altered by a function call)
+            RAX = 0b0000,
+            // non-volatile register (mus be restored on return)
+            RBX = 0b0011,
+            // volatile register (can be altered by a function call)
+            RCX = 0b0001,
+            // volatile register (can be altered by a function call)
+            RDX = 0b0010,
+            // Stack pointer points to the position of the last item that was
+            // pushed to the stack. The stack grows downwards so lower means
+            // more elements in the stack. needs to be aligned to 16 bytes
+            RSP = 0b0100,
+            // non-volatile register (mus be restored on return)
+            RBP = 0b0101,
+            // non-volatile register (mus be restored on return)
+            RSI = 0b0110,
+            // non-volatile register (mus be restored on return)
+            RDI = 0b0111,
+            // volatile register (can be altered by a function call)
+            R8 = 0b1000,
+            // volatile register (can be altered by a function call)
+            R9 = 0b1001,
+            // volatile register (can be altered by a function call)
+            R10 = 0b1010,
+            // volatile register (can be altered by a function call)
+            R11 = 0b1011,
+            // non-volatile register (mus be restored on return)
+            R12 = 0b1100,
+            // non-volatile register (mus be restored on return)
+            R13 = 0b1101,
+            // non-volatile register (mus be restored on return)
+            R14 = 0b1110,
+            // non-volatile register (mus be restored on return)
+            R15 = 0b1111
+        };
+
+        enum SpecialRegister
+        {
+            // Instruction pointer points to the instruction that is executed
+            // next
+            RIP,
+            /**
+              only lower 16 bits are used:
+              - CF: Carry Flag
+              - PF: Parity Flag (1 if an even number of bits was set to 1 in
+              the result of the last operation)
+              - AF: Adjust Flag
+              - ZF: Zero Flag (1 if the result of the last operation was zero)
+              - SF: Sign Flag (1 if the result of the last operation was a
+              positive number)
+              - TF: Trap Flag
+              - IF: Interrupt Flag
+              - DF: Direction Flag
+              - OF: Overflow Flag
+             */
+            FLAGS,
+        };
+
+        /**
+          floating point registers
+         */
+        enum FPRegister
+        {
+            MM0,
+            MM1,
+            MM2,
+            MM3,
+            MM4,
+            MM5,
+            MM6,
+            MM7,
+            MM8,
+            MM9,
+            MM10,
+            MM11,
+            MM12,
+            MM13,
+            MM14,
+            MM15,
+            __FP_REGISTER_COUNT
+        };
+
+        /**
+          describes the bits of the specified register that should be used.
+         */
+        enum GPRegisterPart
+        {
+            LOWER8,
+            HIGHER8,
+            LOWER16,
+            LOWER32,
+            FULL64
+        };
+
+        /**
+          describes the bits of the specified register that should be used.
+         */
+        enum FPRegisterPart
+        {
+            X,
+            Y,
+            // Z
+        };
+
+        class AssemblyBlock;
+        class GPRegisterArgument;
+        class FPRegisterArgument;
+        class MemoryAccessArgument;
+        class ConstantArgument;
+        class JumpTargetArgument;
+
+        /**
+          An argument for an Instruction.
+         */
+        class OperationArgument
+        {
+        private:
+
+        public:
+            /**
+             * checks if a register is used in this argument.
+             *
+             * \param reg the register to check
+             * \return true if the register is used
+             */
+            DLLEXPORT virtual bool usesRegister(GPRegister reg) const;
+            /**
+             * checks if a register is used in this argument.
+             *
+             * \param reg the register to check
+             * \return true if the register is used
+             */
+            DLLEXPORT virtual bool usesRegister(FPRegister reg) const;
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT virtual void replaceRegister(
+                GPRegister oldReg, GPRegister newReg);
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT virtual void replaceRegister(
+                FPRegister oldReg, FPRegister newReg);
+            /**
+             * adds a prefix to all jump labels in this argument to avoid
+             * conflicts if the assembly block that contains this argument is
+             * inlined into another block.
+             *
+             * \param labelPrefix the label prefix to add
+             */
+            DLLEXPORT virtual void addJumpLabelPrefix(Text labelPrefix);
+            /**
+             * \return the GPRegisterArgument or 0 if it is not a
+             * GPRegisterArgument
+             */
+            DLLEXPORT const GPRegisterArgument* asGPRegisterArgument() const;
+            /**
+             * \return the GPRegisterArgument or 0 if it is not a
+             * GPRegisterArgument
+             */
+            DLLEXPORT const MemoryAccessArgument*
+            asMemoryAccessArgument() const;
+            /**
+             * \return the ConstantArgument or 0 if it is not a
+             * ConstantArgument
+             */
+            DLLEXPORT const ConstantArgument* asConstantArgument() const;
+            /**
+             * \return the FPRegisterArgument or 0 if it is not a
+             * FPRegisterArgument
+             */
+            DLLEXPORT const FPRegisterArgument* asFPRegisterArgument() const;
+            /**
+             * \return the JumpTargetArgument or 0 if it is not a
+             * JumpTargetArgument
+             */
+            DLLEXPORT const JumpTargetArgument* asJumpTargetArgument() const;
+        };
+
+        /**
+          Represents the usage of a GPRegister as an Instruction Argument.
+         */
+        class GPRegisterArgument : public OperationArgument
+        {
+        private:
+            GPRegister reg;
+            GPRegisterPart part;
+
+        public:
+            DLLEXPORT GPRegisterArgument(
+                GPRegister reg, GPRegisterPart part = GPRegisterPart::FULL64);
+            DLLEXPORT bool usesRegister(GPRegister reg) const override;
+            DLLEXPORT void replaceRegister(
+                GPRegister oldReg, GPRegister newReg) override;
+            DLLEXPORT GPRegister getRegister() const;
+            DLLEXPORT GPRegisterPart getPart() const;
+        };
+
+        /**
+          Represents the usage of a FPRegister as an Instruction Argument.
+         */
+        class FPRegisterArgument : public OperationArgument
+        {
+        private:
+            FPRegister reg;
+            FPRegisterPart part;
+
+        public:
+            DLLEXPORT FPRegisterArgument(FPRegister reg, FPRegisterPart = X);
+            DLLEXPORT bool usesRegister(FPRegister reg) const override;
+            DLLEXPORT void replaceRegister(
+                FPRegister oldReg, FPRegister newReg) override;
+            DLLEXPORT FPRegister getRegister() const;
+            DLLEXPORT FPRegisterPart getPart() const;
+        };
+
+        enum class MemoryBlockSize
+        {
+            // 8 bist
+            BYTE = 1,
+            // 16 bits
+            WORD = 2,
+            // 32 bits
+            DWORD = 4,
+            // 64 bits
+            QWORD = 8,
+            // 128 bits
+            M128 = 16,
+            // 256 bits
+            M256 = 32,
+            // 512 bits
+            // M512 = 64
+        };
+
+        /**
+          Represents the usage of a Memory Read Request as an Instruction
+          Argument.
+         */
+        class MemoryAccessArgument : public OperationArgument
+        {
+        private:
+            bool useAddressReg;
+            GPRegister address;
+            int offset; // offset from the address in the register
+            GPRegister offsetReg;
+            bool useOffsetReg;
+            MemoryBlockSize blockSize; // size of the block to access (1,2,4,8)
+
+        public:
+            DLLEXPORT MemoryAccessArgument(MemoryBlockSize blockSize,
+                GPRegister address,
+                bool useAddressReg = true,
+                int offset = 0,
+                bool useOffsetReg = false,
+                GPRegister offsetReg = RAX);
+            DLLEXPORT bool usesRegister(GPRegister reg) const override;
+            DLLEXPORT void replaceRegister(
+                GPRegister oldReg, GPRegister newReg) override;
+            DLLEXPORT bool isUsingAddressRegister() const;
+            DLLEXPORT GPRegister getAddressRegister() const;
+            DLLEXPORT int getOffset() const;
+            DLLEXPORT bool isUsingOffsetRegister() const;
+            DLLEXPORT GPRegister getOffsetRegister() const;
+            DLLEXPORT MemoryBlockSize getBlockSize() const;
+        };
+
+        /**
+          Represents the usage of a const value as an Instruction Argument.
+         */
+        class ConstantArgument : public OperationArgument
+        {
+        private:
+            __int64 value;
+            MemoryBlockSize size; // size in byte
+
+        public:
+            DLLEXPORT ConstantArgument(
+                __int64 value, MemoryBlockSize size = MemoryBlockSize::QWORD);
+            DLLEXPORT ConstantArgument(
+                int value, MemoryBlockSize size = MemoryBlockSize::DWORD);
+            DLLEXPORT ConstantArgument(
+                short value, MemoryBlockSize size = MemoryBlockSize::WORD);
+            DLLEXPORT ConstantArgument(
+                char value, MemoryBlockSize size = MemoryBlockSize::BYTE);
+            DLLEXPORT __int64 getValue() const;
+            DLLEXPORT MemoryBlockSize getSize() const;
+        };
+
+        /**
+          Represents the usage of a jump label as an Instruction Argument.
+         */
+        class JumpTargetArgument : public OperationArgument
+        {
+        private:
+            Text name;
+
+        public:
+            DLLEXPORT JumpTargetArgument(Text name);
+            DLLEXPORT void addJumpLabelPrefix(Text labelPrefix) override;
+            const Text& getLabel() const;
+        };
+
+        /**
+          Represents a single assembly instruction with its arguments.
+         */
+        class Instruction : public Framework::ReferenceCounter
+        {
+        private:
+            Operation op;
+            std::vector<OperationArgument*> args;
+
+        public:
+            DLLEXPORT Instruction(
+                Operation op, std::initializer_list<OperationArgument*> params);
+            DLLEXPORT ~Instruction();
+            /**
+             * checks if this instruction reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the instruction reads from the register
+             */
+            DLLEXPORT bool writesToRegister(
+                GPRegister reg, const AssemblyBlock* block) const;
+            /**
+             * checks if this instruction reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the instruction reads from the register
+             */
+            DLLEXPORT bool writesToRegister(
+                FPRegister reg, const AssemblyBlock* block) const;
+            /**
+             * checks if this instruction reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the instruction reads from the register
+             */
+            DLLEXPORT bool readsFromRegister(
+                GPRegister reg, const AssemblyBlock* block) const;
+            /**
+             * checks if this instruction reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the instruction reads from the register
+             */
+            DLLEXPORT bool readsFromRegister(
+                FPRegister reg, const AssemblyBlock* block) const;
+            /**
+             * checks if a register can be replaced by another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             * \return true if the replacement is possible
+             */
+            DLLEXPORT bool isReplacementPossible(GPRegister oldReg,
+                GPRegister newReg,
+                const AssemblyBlock* block) const;
+            /**
+             * checks if a register can be replaced by another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             * \return true if the replacement is possible
+             */
+            DLLEXPORT bool isReplacementPossible(FPRegister oldReg,
+                FPRegister newReg,
+                const AssemblyBlock* block) const;
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT void replaceRegister(
+                GPRegister oldReg, GPRegister newReg);
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT void replaceRegister(
+                FPRegister oldReg, FPRegister newReg);
+            /**
+             * adds a prefix to all jump labels in this instruction to avoid
+             * conflicts if the assembly block that contains this instruction is
+             * inlined into another block.
+             *
+             * \param labelPrefix the label prefix to add
+             */
+            DLLEXPORT void addJumpLabelPrefix(Text labelPrefix);
+            /**
+             * compiles this Instruction to macine code.
+             *
+             * \param machineCodeWriter the machine code will be written to this
+             * writer
+             * \param block the block that contains this instruction. needed to
+             * resolve jump labels
+             */
+            DLLEXPORT void compile(StreamWriter* machineCodeWriter,
+                const AssemblyBlock* block) const;
+            /**
+             * calculates the bytes needed for this instruction in machine code.
+             *
+             * \return the bytes needed
+             */
+            DLLEXPORT int compiledSize(const AssemblyBlock* block) const;
+            /**
+             * \return the op code of this instruction
+             */
+            DLLEXPORT Operation getOperation() const;
+            /**
+             * \return true if the given label is defined by this operation
+             */
+            DLLEXPORT bool definesLabel(Text label) const;
+        };
+
+        /**
+          Represents a block of assembly instructions that can be compiled to
+          machine code or inlined into another AssemblyBlock with addBlock(...).
+         */
+        class AssemblyBlock
+        {
+        private:
+            RCArray<Instruction> instructions;
+            int inlineIndex;
+            void* compiledCode;
+
+        public:
+            DLLEXPORT AssemblyBlock();
+            DLLEXPORT ~AssemblyBlock();
+            /**
+             * adds an instruction.
+             *
+             * \param instr the instruction to add.
+             */
+            DLLEXPORT void addInstruction(Instruction* instr);
+            /**
+             * defines a new jump target label.
+             *
+             * \param name the name of the label.
+             */
+            DLLEXPORT void defineJumpTarget(Text name);
+            /**
+             * adds a jump instruction that jumps to the next Instaruction after
+             * the definition of the given label.
+             *
+             * \param jumpOp the op code of the jump iperation.
+             * \param targetName the label to jump to.
+             */
+            DLLEXPORT void addJump(Operation jumpOp, Text targetName);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(char* valueAddress, GPRegister target);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(short* valueAddress, GPRegister target);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(int* valueAddress, GPRegister target);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(
+                __int64* valueAddress, GPRegister target);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(
+                float* valueAddress, FPRegister target, GPRegister temp = RAX);
+            /**
+             * writes the specified valueAddress pointer into a register.
+             *
+             * \param valueAddress the pointer to the value witch address should
+             * be stored
+             * \param target the register where the address should be stored
+             */
+            DLLEXPORT void addLoadValue(
+                double* valueAddress, FPRegister target, GPRegister temp = RAX);
+            /**
+             * calls a function at a specified memory address.
+             *
+             * \param functionAddress pointet to the address of the function to
+             * call
+             */
+            DLLEXPORT void addCall(
+                void* functionAddress, GPRegister temp = RAX);
+            /**
+             * returns from executing the compiled assembly function.
+             */
+            DLLEXPORT void addReturn();
+            /**
+             * pushes a register into the stack.
+             *
+             * \param reg the register to push
+             * \param part the part of the register to push
+             */
+            DLLEXPORT void addPush(
+                GPRegister reg, GPRegisterPart part = FULL64);
+            /**
+             * pops a value from the sack into a specified register.
+             *
+             * \param reg the register to store the popped value
+             * \param part the part of the register to store the popped value
+             */
+            DLLEXPORT void addPop(GPRegister reg, GPRegisterPart part = FULL64);
+            /**
+             * pushes a register into the stack.
+             *
+             * \param reg the register to push
+             */
+            DLLEXPORT void addPush(FPRegister reg, FPRegisterPart part = X);
+            /**
+             * pops a value from the sack into a specified register.
+             *
+             * \param reg the register to store the popped value
+             */
+            DLLEXPORT void addPop(FPRegister reg, FPRegisterPart part = X);
+            /**
+             * copies the assembly code from a given block of assembly
+             * instructions.
+             *
+             * \param block the block to inline
+             * \param preservedGPRegisters the GP registers that should be
+             * preserved during the inlined block. if a preserved register is
+             * used in the block, it will be replaced by another register or
+             * pushed to the stack if no free register is available.
+             * \param preservedFPRegisters same as preservedGPRegisters but for
+             * FP registers
+             * \param blockResultGpReg if the register RAX should be preserved
+             * this pointer will be set to the register that was selected to
+             * replace RAX during execution of the block.
+             * \param blockResultFpReg same as blockResultGpReg but for XMM0
+             */
+            DLLEXPORT void addBlock(AssemblyBlock* block,
+                std::initializer_list<GPRegister> preservedGPRegisters,
+                std::initializer_list<FPRegister> preservedFPRegisters,
+                GPRegister* blockResultGpReg,
+                FPRegister* blockResultFpReg);
+            /**
+             * checks if this block writes to a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the block writes to the register
+             */
+            DLLEXPORT bool writesToRegister(GPRegister reg) const;
+            /**
+             * checks if this block writes to a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the block writes to the register
+             */
+            DLLEXPORT bool writesToRegister(FPRegister reg) const;
+            /**
+             * checks if this block reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the block reads from the register
+             */
+            DLLEXPORT bool readsFromRegister(GPRegister reg) const;
+            /**
+             * checks if this block reads from a specified register.
+             *
+             * \param reg the register to check
+             * \return true if the block reads from the register
+             */
+            DLLEXPORT bool readsFromRegister(FPRegister reg) const;
+            /**
+             * checks if a register can be replaced by another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             * \return true if the replacement is possible
+             */
+            DLLEXPORT bool isReplacementPossible(
+                GPRegister oldReg, GPRegister newReg) const;
+            /**
+             * checks if a register can be replaced by another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             * \return true if the replacement is possible
+             */
+            DLLEXPORT bool isReplacementPossible(
+                FPRegister oldReg, FPRegister newReg) const;
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT void replaceRegister(
+                GPRegister oldReg, GPRegister newReg);
+            /**
+             * replaces a register with another register.
+             *
+             * \param oldReg the register to replace
+             * \param newReg the register to use instead
+             */
+            DLLEXPORT void replaceRegister(
+                FPRegister oldReg, FPRegister newReg);
+            /**
+             * adds a prefix to all jump labels in this block to avoid conflicts
+             * if this block is inlined into another block.
+             *
+             * \param labelPrefix the label prefix to add
+             */
+            DLLEXPORT void addJumpLabelPrefix(Text labelPrefix);
+            /**
+             * \return the instructions of this block
+             */
+            DLLEXPORT const RCArray<Instruction>& getInstructions() const;
+            /**
+             * \return a pointer to a function that contains the compiled byte
+             * code of this assembly block. and can be called directly with
+             * reinterpret_cast<returnType(*)(parameterTypes...)>(compile())(parameters...)
+             */
+            DLLEXPORT void* compile();
+        };
+    } // namespace Assembly
+} // namespace Framework

DX12PixelShader.h

@@ -92,10 +92,10 @@ ret
 
 const BYTE DX12PixelShaderBytes[] =
 {
-     68,  88,  66,  67, 156, 122, 
-     96, 209,  90,  75,  27,   0, 
-    111, 199, 129,  60,  59, 117, 
-     76,  14,   1,   0,   0,   0, 
+     68,  88,  66,  67, 149, 192, 
+    216, 146, 253, 151, 104, 216, 
+     23, 204,   1,  32,  33, 228, 
+    130, 142,   1,   0,   0,   0, 
     184,  91,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
      36,   2,   0,   0, 188,   2, 
@@ -342,8 +342,8 @@ const BYTE DX12PixelShaderBytes[] =
      70,  32,  55,  46,  48,  48, 
      13,  10,  26,  68,  83,   0, 
       0,   0,   0,   2,   0,   0, 
-      1,   0,   0,   0,  43,   0, 
-      0,   0, 204,   0,   0,   0, 
+      2,   0,   0,   0,  43,   0, 
+      0,   0, 200,   0,   0,   0, 
       0,   0,   0,   0,  39,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -421,8 +421,7 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 224,   1,   0,   0, 
-      0, 255, 255, 255, 255, 255, 
+      0,   0, 192, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -506,8 +505,9 @@ const BYTE DX12PixelShaderBytes[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  24, 254, 
     255, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255,  56,   0, 
+      0,   0,   0, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -592,164 +592,11 @@ const BYTE DX12PixelShaderBytes[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    101, 114,  84, 101, 120, 116, 
-    117, 114, 101,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  32, 116,  48, 
-     32,  41,  59,  13,  10,  83, 
-     97, 109, 112, 108, 101, 114, 
-     83, 116,  97, 116, 101,  32, 
-     83,  97, 109, 112, 108, 101, 
-     84, 121, 112, 101,  32,  58, 
-     32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40,  32, 115, 
-     48,  32,  41,  59,  13,  10, 
-     13,  10,  47,  47,  32,  77, 
-     97, 116, 114, 105, 122, 101, 
-    110,  32, 102, 252, 114,  32, 
-    100, 105, 101,  32, 101, 105, 
-    110, 122, 101, 108, 110, 101, 
-    110,  32,  75, 110, 111,  99, 
-    104, 101, 110,  32, 100, 101, 
-    115,  32,  77, 111, 100, 101, 
-    108, 108, 115,  13,  10, 115, 
-    116, 114, 117,  99, 116,  32, 
-     77,  97, 116, 114, 105, 120, 
-     66, 117, 102, 102, 101, 114, 
-     13,  10, 123,  13,  10,  32, 
-     32,  32,  32, 109,  97, 116, 
-    114, 105, 120,  32, 107, 110, 
-    111,  99, 104, 101, 110,  77, 
-     97, 116, 114, 105, 120,  91, 
-     32,  49,  50,  56,  32,  93, 
-     59,  13,  10, 125,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-     84, 104, 101,  32, 112, 114, 
-    111, 106, 101,  99, 116, 105, 
-    111, 110,  32,  97, 110, 100, 
-     32, 118, 105, 101, 119,  32, 
-    109,  97, 116, 114, 105, 120, 
-     13,  10, 115, 116, 114, 117, 
-     99, 116,  32,  75,  97, 109, 
-    101, 114,  97,  66, 117, 102, 
-    102, 101, 114,  50,  13,  10, 
-    123,  13,  10,  32,  32,  32, 
-     32, 109,  97, 116, 114, 105, 
-    120,  32, 118, 105, 101, 119, 
-     59,  13,  10,  32,  32,  32, 
-     32, 109,  97, 116, 114, 105, 
-    120,  32, 112, 114, 111, 106, 
-    101,  99, 116, 105, 111, 110, 
-     59,  13,  10, 125,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-     84, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 111, 102,  32, 116, 104, 
-    101,  32, 107,  97, 109, 101, 
-    114,  97,  13,  10, 115, 116, 
-    114, 117,  99, 116,  32,  75, 
-     97, 109, 101, 114,  97,  66, 
-    117, 102, 102, 101, 114,  13, 
-     10, 123,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  52,  32, 107,  80, 111, 
-    115, 105, 116, 105, 111, 110, 
-     59,  13,  10, 125,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-    116, 104, 101, 115, 101,  32, 
-    118,  97, 108, 117, 101, 115, 
-     32, 115, 104, 111, 117, 108, 
-    100,  32, 115, 117, 109,  32, 
-    117, 112,  32, 116, 111,  32, 
-     49,  13,  10, 115, 116, 114, 
-    117,  99, 116,  32,  77,  97, 
-    116, 101, 114, 105,  97, 108, 
-     13,  10, 123,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32,  97, 109,  98, 
-    105, 101, 110, 116,  70,  97, 
-     99, 116, 111, 114,  59,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32, 100, 
-    105, 102, 102, 117, 115,  70, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  32, 
-    115, 112, 101,  99, 117, 108, 
-     97, 114,  70,  97,  99, 116, 
-    111, 114,  14, 219,   3,   0, 
-    197,  74,   0,   0, 165, 207, 
-      1,   0, 242,  56,   1,   0, 
-     43, 236,   3,   0,  28,  19, 
-      2,   0,  65,  36,   1,   0, 
-    236, 179,   1,   0, 184, 213, 
-      0,   0, 125,  10,   2,   0, 
-    125, 181,   2,   0, 116, 163, 
-      3,   0, 193,  33,   3,   0, 
-     65, 185,   2,   0, 140, 239, 
-      1,   0, 246,  49,   0,   0, 
-    213, 255,   0,   0, 180,  18, 
-      0,   0, 202, 179,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+      5,   0,   0,   0,  32,   0, 
+      0,   0,  60,   0,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+      6,   0,   0,   0,   5,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -762,17 +609,8 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 148,  46, 
-     49,   1,   6, 118,  88, 104, 
-      1,   0,   0,   0, 129, 231, 
-    186,  31, 103, 104, 126,  69, 
-    138, 219,  59,  55, 121,  10, 
-    174, 188,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    220,  81,  51,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -839,6 +677,7 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -848,10 +687,6 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255, 119,   9, 
-     49,   1,   0,   0,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -927,19 +762,23 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 148,  46, 
+     49,   1,  76, 224, 173, 104, 
+      1,   0,   0,   0, 118,  43, 
+    241, 153, 212, 204,  58,  76, 
+    157,  15,  19, 216, 183, 230, 
+    127, 195,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    220,  81,  51,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     32,   0,   0,   0,  60,   0, 
       0,   0,   0,   0,   0,   0, 
-     64,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1009,30 +848,105 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+    101, 114,  84, 101, 120, 116, 
+    117, 114, 101,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40,  32, 116,  48, 
+     32,  41,  59,  13,  10,  83, 
+     97, 109, 112, 108, 101, 114, 
+     83, 116,  97, 116, 101,  32, 
+     83,  97, 109, 112, 108, 101, 
+     84, 121, 112, 101,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  32, 115, 
+     48,  32,  41,  59,  13,  10, 
+     13,  10,  47,  47,  32,  77, 
+     97, 116, 114, 105, 122, 101, 
+    110,  32, 102, 252, 114,  32, 
+    100, 105, 101,  32, 101, 105, 
+    110, 122, 101, 108, 110, 101, 
+    110,  32,  75, 110, 111,  99, 
+    104, 101, 110,  32, 100, 101, 
+    115,  32,  77, 111, 100, 101, 
+    108, 108, 115,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     77,  97, 116, 114, 105, 120, 
+     66, 117, 102, 102, 101, 114, 
+     13,  10, 123,  13,  10,  32, 
+     32,  32,  32, 109,  97, 116, 
+    114, 105, 120,  32, 107, 110, 
+    111,  99, 104, 101, 110,  77, 
+     97, 116, 114, 105, 120,  91, 
+     32,  49,  50,  56,  32,  93, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+     84, 104, 101,  32, 112, 114, 
+    111, 106, 101,  99, 116, 105, 
+    111, 110,  32,  97, 110, 100, 
+     32, 118, 105, 101, 119,  32, 
+    109,  97, 116, 114, 105, 120, 
+     13,  10, 115, 116, 114, 117, 
+     99, 116,  32,  75,  97, 109, 
+    101, 114,  97,  66, 117, 102, 
+    102, 101, 114,  50,  13,  10, 
+    123,  13,  10,  32,  32,  32, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32, 118, 105, 101, 119, 
+     59,  13,  10,  32,  32,  32, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+     84, 104, 101,  32, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     32, 111, 102,  32, 116, 104, 
+    101,  32, 107,  97, 109, 101, 
+    114,  97,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  75, 
+     97, 109, 101, 114,  97,  66, 
+    117, 102, 102, 101, 114,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  52,  32, 107,  80, 111, 
+    115, 105, 116, 105, 111, 110, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+    116, 104, 101, 115, 101,  32, 
+    118,  97, 108, 117, 101, 115, 
+     32, 115, 104, 111, 117, 108, 
+    100,  32, 115, 117, 109,  32, 
+    117, 112,  32, 116, 111,  32, 
+     49,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  77,  97, 
+    116, 101, 114, 105,  97, 108, 
+     13,  10, 123,  13,  10,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  32,  97, 109,  98, 
+    105, 101, 110, 116,  70,  97, 
+     99, 116, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 100, 
+    105, 102, 102, 117, 115,  70, 
+     97,  99, 116, 111, 114,  59, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 111,  97, 116,  32, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  70,  97,  99, 116, 
+    111, 114, 198,  90,   0,   0, 
+    117, 131,   1,   0,  76, 232, 
+      3,   0, 242,  56,   1,   0, 
+     43, 236,   3,   0,  28,  19, 
+      2,   0,  65,  36,   1,   0, 
+    236, 179,   1,   0, 187,  26, 
+      0,   0, 125,  10,   2,   0, 
+    125, 181,   2,   0, 200,  81, 
+      2,   0, 193,  33,   3,   0, 
+     65, 185,   2,   0, 140, 239, 
+      1,   0, 246,  49,   0,   0, 
+    213, 255,   0,   0, 251, 202, 
+      2,   0, 202, 179,   0,   0, 
+      0,  16,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1104,9 +1018,9 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     47,  32,  32,  32,  32,  32, 
+     47,  47,  47,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1121,10 +1035,10 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  71,  76,  79,  66,  65, 
-     76,  83,  32,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  32,  71, 
+     76,  79,  66,  65,  76,  83, 
+     32,  47,  47,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1139,9 +1053,10 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  47,  47, 
+     32,  32,  32,  32,  13,  10, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  32,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1156,209 +1071,208 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     84, 101, 120, 116, 117, 114, 
-    101,  50,  68,  32, 115, 104, 
-     97, 100, 101, 114,  84, 101, 
-    120, 116, 117, 114, 101,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40,  32, 
-    116,  48,  32,  41,  59,  13, 
-     10,  83,  97, 109, 112, 108, 
-    101, 114,  83, 116,  97, 116, 
-    101,  32,  83,  97, 109, 112, 
-    108, 101,  84, 121, 112, 101, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     32, 115,  48,  32,  41,  59, 
-     13,  10,  13,  10,  47,  47, 
-     32,  77,  97, 116, 114, 105, 
-    122, 101, 110,  32, 102, 252, 
-    114,  32, 100, 105, 101,  32, 
-    101, 105, 110, 122, 101, 108, 
-    110, 101, 110,  32,  75, 110, 
-    111,  99, 104, 101, 110,  32, 
-    100, 101, 115,  32,  77, 111, 
-    100, 101, 108, 108, 115,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  77,  97, 116, 114, 
-    105, 120,  66, 117, 102, 102, 
-    101, 114,  13,  10, 123,  13, 
-     10,  32,  32,  32,  32, 109, 
-     97, 116, 114, 105, 120,  32, 
-    107, 110, 111,  99, 104, 101, 
-    110,  77,  97, 116, 114, 105, 
-    120,  91,  32,  49,  50,  56, 
-     32,  93,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  47, 
-     47,  32,  84, 104, 101,  32, 
-    112, 114, 111, 106, 101,  99, 
-    116, 105, 111, 110,  32,  97, 
-    110, 100,  32, 118, 105, 101, 
-    119,  32, 109,  97, 116, 114, 
-    105, 120,  13,  10, 115, 116, 
-    114, 117,  99, 116,  32,  75, 
-     97, 109, 101, 114,  97,  66, 
-    117, 102, 102, 101, 114,  50, 
+     32,  32,  13,  10,  84, 101, 
+    120, 116, 117, 114, 101,  50, 
+     68,  32, 115, 104,  97, 100, 
+    101, 114,  84, 101, 120, 116, 
+    117, 114, 101,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40,  32, 116,  48, 
+     32,  41,  59,  13,  10,  83, 
+     97, 109, 112, 108, 101, 114, 
+     83, 116,  97, 116, 101,  32, 
+     83,  97, 109, 112, 108, 101, 
+     84, 121, 112, 101,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  32, 115, 
+     48,  32,  41,  59,  13,  10, 
+     13,  10,  47,  47,  32,  77, 
+     97, 116, 114, 105, 122, 101, 
+    110,  32, 102, 252, 114,  32, 
+    100, 105, 101,  32, 101, 105, 
+    110, 122, 101, 108, 110, 101, 
+    110,  32,  75, 110, 111,  99, 
+    104, 101, 110,  32, 100, 101, 
+    115,  32,  77, 111, 100, 101, 
+    108, 108, 115,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     77,  97, 116, 114, 105, 120, 
+     66, 117, 102, 102, 101, 114, 
      13,  10, 123,  13,  10,  32, 
      32,  32,  32, 109,  97, 116, 
-    114, 105, 120,  32, 118, 105, 
-    101, 119,  59,  13,  10,  32, 
-     32,  32,  32, 109,  97, 116, 
-    114, 105, 120,  32, 112, 114, 
+    114, 105, 120,  32, 107, 110, 
+    111,  99, 104, 101, 110,  77, 
+     97, 116, 114, 105, 120,  91, 
+     32,  49,  50,  56,  32,  93, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+     84, 104, 101,  32, 112, 114, 
     111, 106, 101,  99, 116, 105, 
-    111, 110,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  47, 
-     47,  32,  84, 104, 101,  32, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  32, 111, 102,  32, 
-    116, 104, 101,  32, 107,  97, 
-    109, 101, 114,  97,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  75,  97, 109, 101, 114, 
-     97,  66, 117, 102, 102, 101, 
-    114,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  52,  32, 107, 
-     80, 111, 115, 105, 116, 105, 
-    111, 110,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  47, 
-     47,  32, 116, 104, 101, 115, 
-    101,  32, 118,  97, 108, 117, 
-    101, 115,  32, 115, 104, 111, 
-    117, 108, 100,  32, 115, 117, 
-    109,  32, 117, 112,  32, 116, 
-    111,  32,  49,  13,  10, 115, 
-    116, 114, 117,  99, 116,  32, 
-     77,  97, 116, 101, 114, 105, 
-     97, 108,  13,  10, 123,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32,  97, 
-    109,  98, 105, 101, 110, 116, 
-     70,  97,  99, 116, 111, 114, 
+    111, 110,  32,  97, 110, 100, 
+     32, 118, 105, 101, 119,  32, 
+    109,  97, 116, 114, 105, 120, 
+     13,  10, 115, 116, 114, 117, 
+     99, 116,  32,  75,  97, 109, 
+    101, 114,  97,  66, 117, 102, 
+    102, 101, 114,  50,  13,  10, 
+    123,  13,  10,  32,  32,  32, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32, 118, 105, 101, 119, 
      59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     32, 100, 105, 102, 102, 117, 
-    115,  70,  97,  99, 116, 111, 
-    114,  59,  13,  10,  32,  32, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+     84, 104, 101,  32, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     32, 111, 102,  32, 116, 104, 
+    101,  32, 107,  97, 109, 101, 
+    114,  97,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  75, 
+     97, 109, 101, 114,  97,  66, 
+    117, 102, 102, 101, 114,  13, 
+     10, 123,  13,  10,  32,  32, 
      32,  32, 102, 108, 111,  97, 
-    116,  32, 115, 112, 101,  99, 
-    117, 108,  97, 114,  70,  97, 
-     99, 116, 111, 114,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  76, 105, 103, 104, 
-    116,  67, 111, 117, 110, 116, 
+    116,  52,  32, 107,  80, 111, 
+    115, 105, 116, 105, 111, 110, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+    116, 104, 101, 115, 101,  32, 
+    118,  97, 108, 117, 101, 115, 
+     32, 115, 104, 111, 117, 108, 
+    100,  32, 115, 117, 109,  32, 
+    117, 112,  32, 116, 111,  32, 
+     49,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  77,  97, 
+    116, 101, 114, 105,  97, 108, 
      13,  10, 123,  13,  10,  32, 
-     32,  32,  32, 105, 110, 116, 
-     32, 100, 105, 102, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  32,  97, 109,  98, 
+    105, 101, 110, 116,  70,  97, 
+     99, 116, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 100, 
+    105, 102, 102, 117, 115,  70, 
+     97,  99, 116, 111, 114,  59, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 111,  97, 116,  32, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  70,  97,  99, 116, 
+    111, 114,  59,  13,  10, 125, 
+     59,  13,  10,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  13,  10, 
+    123,  13,  10,  32,  32,  32, 
+     32, 105, 110, 116,  32, 100, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  59,  13, 
+     10,  32,  32,  32,  32, 105, 
+    110, 116,  32, 112, 111, 105, 
+    110, 116,  76, 105, 103, 104, 
     116,  67, 111, 117, 110, 116, 
-     59,  13,  10,  32,  32,  32, 
-     32, 105, 110, 116,  32, 112, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  67, 
-    111, 110, 115, 116,  97, 110, 
-    116,  66, 117, 102, 102, 101, 
-    114,  60,  75,  97, 109, 101, 
-    114,  97,  66, 117, 102, 102, 
-    101, 114,  50,  62,  32,  75, 
-     97, 109, 101, 114,  97,  50, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     32,  98,  48,  32,  41,  59, 
-     13,  10,  67, 111, 110, 115, 
-    116,  97, 110, 116,  66, 117, 
-    102, 102, 101, 114,  60,  77, 
-     97, 116, 114, 105, 120,  66, 
-    117, 102, 102, 101, 114,  62, 
-     32,  83, 107, 101, 108, 101, 
-    116, 116,  32,  58,  32, 114, 
-    101, 103, 105, 115, 116, 101, 
-    114,  40,  32,  98,  49,  32, 
-     41,  59,  13,  10,  67, 111, 
-    110, 115, 116,  97, 110, 116, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  67, 111, 110, 
+    115, 116,  97, 110, 116,  66, 
+    117, 102, 102, 101, 114,  60, 
+     75,  97, 109, 101, 114,  97, 
      66, 117, 102, 102, 101, 114, 
-     60,  75,  97, 109, 101, 114, 
-     97,  66, 117, 102, 102, 101, 
-    114,  62,  32,  75,  97, 109, 
-    101, 114,  97,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  32,  98,  50, 
-     32,  41,  59,  13,  10,  67, 
-    111, 110, 115, 116,  97, 110, 
-    116,  66, 117, 102, 102, 101, 
-    114,  60,  77,  97, 116, 101, 
-    114, 105,  97, 108,  62,  32, 
-     79,  98, 106, 101,  99, 116, 
+     50,  62,  32,  75,  97, 109, 
+    101, 114,  97,  50,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  32,  98, 
+     48,  32,  41,  59,  13,  10, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116,  66, 117, 102, 102, 
+    101, 114,  60,  77,  97, 116, 
+    114, 105, 120,  66, 117, 102, 
+    102, 101, 114,  62,  32,  83, 
+    107, 101, 108, 101, 116, 116, 
      32,  58,  32, 114, 101, 103, 
     105, 115, 116, 101, 114,  40, 
-     32,  98,  51,  32,  41,  59, 
+     32,  98,  49,  32,  41,  59, 
      13,  10,  67, 111, 110, 115, 
     116,  97, 110, 116,  66, 117, 
-    102, 102, 101, 114,  60,  76, 
-    105, 103, 104, 116,  67, 111, 
-    117, 110, 116,  62,  32,  76, 
-    105, 103, 104, 116,  32,  58, 
+    102, 102, 101, 114,  60,  75, 
+     97, 109, 101, 114,  97,  66, 
+    117, 102, 102, 101, 114,  62, 
+     32,  75,  97, 109, 101, 114, 
+     97,  32,  58,  32, 114, 101, 
+    103, 105, 115, 116, 101, 114, 
+     40,  32,  98,  50,  32,  41, 
+     59,  13,  10,  67, 111, 110, 
+    115, 116,  97, 110, 116,  66, 
+    117, 102, 102, 101, 114,  60, 
+     77,  97, 116, 101, 114, 105, 
+     97, 108,  62,  32,  79,  98, 
+    106, 101,  99, 116,  32,  58, 
      32, 114, 101, 103, 105, 115, 
     116, 101, 114,  40,  32,  98, 
-     52,  32,  41,  59,  13,  10, 
-     13,  10,  47,  47,  32, 108, 
-    105, 103, 104, 116, 115,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  68, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  13,  10, 123,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  51,  32, 
-    100, 105, 114, 101,  99, 116, 
-    105, 111, 110,  59,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  51,  32,  99, 
-    111, 108, 111, 114,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  80, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
+     51,  32,  41,  59,  13,  10, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116,  66, 117, 102, 102, 
+    101, 114,  60,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,  62,  32,  76, 105, 103, 
+    104, 116,  32,  58,  32, 114, 
+    101, 103, 105, 115, 116, 101, 
+    114,  40,  32,  98,  52,  32, 
+     41,  59,  13,  10,  13,  10, 
+     47,  47,  32, 108, 105, 103, 
+    104, 116, 115,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     68, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
      13,  10, 123,  13,  10,  32, 
      32,  32,  32, 102, 108, 111, 
-     97, 116,  51,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     51,  32,  99, 111, 108, 111, 
-    114,  59,  13,  10,  32,  32, 
+     97, 116,  51,  32, 100, 105, 
+    114, 101,  99, 116, 105, 111, 
+    110,  59,  13,  10,  32,  32, 
      32,  32, 102, 108, 111,  97, 
-    116,  32, 114,  97, 100, 105, 
-    117, 115,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  47, 
-     47,  83, 116, 114, 117,  99, 
-    116, 117, 114, 101, 100,  66, 
-    117, 102, 102, 101, 114,  60, 
-     32,  68, 105, 102, 102, 117, 
+    116,  51,  32,  99, 111, 108, 
+    111, 114,  59,  13,  10, 125, 
+     59,  13,  10,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     80, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116,  13,  10, 
+    123,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     51,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  51,  32, 
+     99, 111, 108, 111, 114,  59, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 111,  97, 116,  32, 
+    114,  97, 100, 105, 117, 115, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  83, 
+    116, 114, 117,  99, 116, 117, 
+    114, 101, 100,  66, 117, 102, 
+    102, 101, 114,  60,  32,  68, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  32, 
+     62,  32, 100, 105, 102, 117, 
     115, 101,  76, 105, 103, 104, 
-    116,  32,  62,  32, 100, 105, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116, 115,  32,  58, 
-     32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40,  32, 116, 
-     49,  32,  41,  59,  13,  10, 
-     47,  47,  83, 116, 114, 117, 
-     99, 116, 117, 114, 101, 100, 
-     66, 117, 102, 102, 101, 114, 
-     60,  32,  80, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-     32,  62,  32, 112, 111, 105, 
-    110, 116,  76, 105, 103, 104, 
     116, 115,  32,  58,  32, 114, 
     101, 103, 105, 115, 116, 101, 
-    114,  40,  32, 116,  50,  32, 
-     41,  59,  13,  10,  13,  10, 
+    114,  40,  32, 116,  49,  32, 
+     41,  59,  13,  10,  47,  47, 
+     83, 116, 114, 117,  99, 116, 
+    117, 114, 101, 100,  66, 117, 
+    102, 102, 101, 114,  60,  32, 
+     80, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116,  32,  62, 
+     32, 112, 111, 105, 110, 116, 
+     76, 105, 103, 104, 116, 115, 
+     32,  58,  32, 114, 101, 103, 
+    105, 115, 116, 101, 114,  40, 
+     32, 116,  50,  32,  41,  59, 
+     13,  10,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1373,10 +1287,10 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  84,  89,  80,  69,  68, 
-     69,  70,  83,  32,  47,  47, 
      32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  32,  84, 
+     89,  80,  69,  68,  69,  70, 
+     83,  32,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1391,9 +1305,10 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  47,  47, 
+     32,  32,  32,  32,  13,  10, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1408,34 +1323,33 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  13,  10, 123, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  52, 
-     32, 119, 111, 114, 108, 100, 
-     80, 111, 115,  32,  58,  32, 
-     80,  79,  83,  73,  84,  73, 
-     79,  78,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  52,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32,  58,  32,  83,  86,  95, 
-     80,  79,  83,  73,  84,  73, 
-     79,  78,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  50,  32, 116, 101, 
-    120,  32,  58,  32,  84,  69, 
-     88,  67,  79,  79,  82,  68, 
+     32,  32,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  52,  32, 119, 
+    111, 114, 108, 100,  80, 111, 
+    115,  32,  58,  32,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
      59,  13,  10,  32,  32,  32, 
      32, 102, 108, 111,  97, 116, 
-     51,  32, 110, 111, 114, 109, 
-     97, 108,  32,  58,  32,  78, 
-     79,  82,  77,  65,  76,  59, 
-     13,  10, 125,  59,  13,  10, 
-     13,  10,  47,  47,  47,  47, 
+     52,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32,  58, 
+     32,  83,  86,  95,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     50,  32, 116, 101, 120,  32, 
+     58,  32,  84,  69,  88,  67, 
+     79,  79,  82,  68,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  51,  32, 
+    110, 111, 114, 109,  97, 108, 
+     32,  58,  32,  78,  79,  82, 
+     77,  65,  76,  59,  13,  10, 
+    125,  59,  13,  10,  13,  10, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -1448,14 +1362,15 @@ const BYTE DX12PixelShaderBytes[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     47,  47,  32,  80, 105, 120, 
-    101, 108,  32,  83, 104,  97, 
-    100, 101, 114,  32,  32,  32, 
+     32,  32,  13,  10,  47,  47, 
+     32,  80, 105, 120, 101, 108, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1470,8 +1385,7 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
+     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -1484,69 +1398,48 @@ const BYTE DX12PixelShaderBytes[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     13,  10, 102, 108, 111,  97, 
-    116,  52,  32, 109,  97, 105, 
-    110,  40,  32,  80, 105, 120, 
-    101, 108,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,  32, 
-    105, 110, 112, 117, 116,  32, 
-     41,  32,  58,  32,  83,  86, 
-     95,  84,  65,  82,  71,  69, 
-     84,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  51,  32, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  32, 
-     61,  32, 102, 108, 111,  97, 
-    116,  51,  40,  32,  48,  44, 
-     32,  48,  44,  32,  48,  32, 
-     41,  59,  13,  10,  32,  32, 
+     32,  32,  32,  32,  13,  10, 
+    102, 108, 111,  97, 116,  52, 
+     32, 109,  97, 105, 110,  40, 
+     32,  80, 105, 120, 101, 108, 
+     73, 110, 112, 117, 116,  84, 
+    121, 112, 101,  32, 105, 110, 
+    112, 117, 116,  32,  41,  32, 
+     58,  32,  83,  86,  95,  84, 
+     65,  82,  71,  69,  84,  13, 
+     10, 123,  13,  10,  32,  32, 
      32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 115, 112, 101, 
-     99, 117, 108,  97, 114,  76, 
-    105, 103, 104, 116,  32,  61, 
-     32, 102, 108, 111,  97, 116, 
-     51,  40,  32,  48,  44,  32, 
-     48,  44,  32,  48,  32,  41, 
-     59,  13,  10,  32,  32,  32, 
-     47,  42,  32, 102, 111, 114, 
-     40,  32, 105, 110, 116,  32, 
-    106,  32,  61,  32,  48,  59, 
-     32, 106,  32,  60,  32,  76, 
-    105, 103, 104, 116,  46, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  67, 
-    111, 117, 110, 116,  59,  32, 
-    106,  43,  43,  32,  41,  13, 
-     10,  32,  32,  32,  32, 123, 
+    116,  51,  32, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  32,  61,  32, 
+    102, 108, 111,  97, 116,  51, 
+     40,  32,  48,  44,  32,  48, 
+     44,  32,  48,  32,  41,  59, 
      13,  10,  32,  32,  32,  32, 
-     32,  32,  32,  32, 105, 102, 
-     40,  32, 100, 111, 116,  40, 
-     32, 105, 110, 112, 117, 116, 
-     46, 110, 111, 114, 109,  97, 
-    108,  44,  32,  45, 100, 105, 
+    102, 108, 111,  97, 116,  51, 
+     32, 115, 112, 101,  99, 117, 
+    108,  97, 114,  76, 105, 103, 
+    104, 116,  32,  61,  32, 102, 
+    108, 111,  97, 116,  51,  40, 
+     32,  48,  44,  32,  48,  44, 
+     32,  48,  32,  41,  59,  13, 
+     10,  32,  32,  32,  47,  42, 
+     32, 102, 111, 114,  40,  32, 
+    105, 110, 116,  32, 106,  32, 
+     61,  32,  48,  59,  32, 106, 
+     32,  60,  32,  76, 105, 103, 
+    104, 116,  46, 100, 105, 102, 
     102, 117, 115, 101,  76, 105, 
-    103, 104, 116, 115,  91,  32, 
-    106,  32,  93,  46, 100, 105, 
-    114, 101,  99, 116, 105, 111, 
-    110,  32,  41,  32,  60,  32, 
-     48,  32,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  99, 
-    111, 110, 116, 105, 110, 117, 
-    101,  59,  13,  10,  32,  32, 
+    103, 104, 116,  67, 111, 117, 
+    110, 116,  59,  32, 106,  43, 
+     43,  32,  41,  13,  10,  32, 
+     32,  32,  32, 123,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     32,  43,  61,  32, 100, 105, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116, 115,  91,  32, 
-    106,  32,  93,  46,  99, 111, 
-    108, 111, 114,  32,  42,  32, 
+     32,  32, 105, 102,  40,  32, 
     100, 111, 116,  40,  32, 105, 
     110, 112, 117, 116,  46, 110, 
     111, 114, 109,  97, 108,  44, 
@@ -1555,101 +1448,83 @@ const BYTE DX12PixelShaderBytes[] =
     116, 115,  91,  32, 106,  32, 
      93,  46, 100, 105, 114, 101, 
      99, 116, 105, 111, 110,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32, 125,  13,  10,  32, 
-     32,  32,  32, 102, 111, 114, 
-     40,  32, 105, 110, 116,  32, 
-    105,  32,  61,  32,  48,  59, 
-     32, 105,  32,  60,  32,  76, 
-    105, 103, 104, 116,  46, 112, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  59,  32, 105,  43, 
-     43,  32,  41,  13,  10,  32, 
-     32,  32,  32, 123,  13,  10, 
+     41,  32,  60,  32,  48,  32, 
+     41,  13,  10,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 108, 105, 103, 
-    104, 116,  68, 105, 114,  32, 
-     61,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-    115,  91,  32, 105,  32,  93, 
-     46, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32,  45,  32, 
-    105, 110, 112, 117, 116,  46, 
-    119, 111, 114, 108, 100,  80, 
-    111, 115,  46, 120, 121, 122, 
-     59,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32, 102, 
-     97,  99, 116, 111, 114,  32, 
-     61,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-    115,  91,  32, 105,  32,  93, 
-     46, 114,  97, 100, 105, 117, 
-    115,  32,  47,  32, 108, 101, 
-    110, 103, 116, 104,  40,  32, 
-    108, 105, 103, 104, 116,  68, 
-    105, 114,  32,  41,  59,  13, 
-     10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32, 102,  32,  61, 
-     32, 100, 111, 116,  40,  32, 
-    105, 110, 112, 117, 116,  46, 
-    110, 111, 114, 109,  97, 108, 
-     44,  32, 110, 111, 114, 109, 
-     97, 108, 105, 122, 101,  40, 
-     32, 108, 105, 103, 104, 116, 
-     68, 105, 114,  32,  41,  32, 
-     41,  59,  13,  10,  32,  32, 
+     32,  32,  32,  99, 111, 110, 
+    116, 105, 110, 117, 101,  59, 
+     13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116,  32,  43, 
+     61,  32, 100, 105, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116, 115,  91,  32, 106,  32, 
+     93,  46,  99, 111, 108, 111, 
+    114,  32,  42,  32, 100, 111, 
+    116,  40,  32, 105, 110, 112, 
+    117, 116,  46, 110, 111, 114, 
+    109,  97, 108,  44,  32,  45, 
+    100, 105, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116, 115, 
+     91,  32, 106,  32,  93,  46, 
+    100, 105, 114, 101,  99, 116, 
+    105, 111, 110,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+    125,  13,  10,  32,  32,  32, 
+     32, 102, 111, 114,  40,  32, 
+    105, 110, 116,  32, 105,  32, 
+     61,  32,  48,  59,  32, 105, 
+     32,  60,  32,  76, 105, 103, 
+    104, 116,  46, 112, 111, 105, 
+    110, 116,  76, 105, 103, 104, 
+    116,  67, 111, 117, 110, 116, 
+     59,  32, 105,  43,  43,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-    105, 102,  40,  32, 102,  32, 
-     62,  32,  48,  32,  41,  13, 
+    102, 108, 111,  97, 116,  51, 
+     32, 108, 105, 103, 104, 116, 
+     68, 105, 114,  32,  61,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  91, 
+     32, 105,  32,  93,  46, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  45,  32, 105, 110, 
+    112, 117, 116,  46, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+     46, 120, 121, 122,  59,  13, 
      10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 123,  13,  10, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     32,  43,  61,  32, 112, 111, 
-    105, 110, 116,  76, 105, 103, 
-    104, 116, 115,  91,  32, 105, 
-     32,  93,  46,  99, 111, 108, 
-    111, 114,  32,  42,  32, 102, 
-     32,  42,  32, 102,  97,  99, 
-    116, 111, 114,  59,  13,  10, 
-     32,  32,  32,  32,  32,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  32, 102,  97,  99, 
+    116, 111, 114,  32,  61,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  91, 
+     32, 105,  32,  93,  46, 114, 
+     97, 100, 105, 117, 115,  32, 
+     47,  32, 108, 101, 110, 103, 
+    116, 104,  40,  32, 108, 105, 
+    103, 104, 116,  68, 105, 114, 
+     32,  41,  59,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
-    102,  32,  61,  32, 100, 111, 
-    116,  40,  32, 110, 111, 114, 
-    109,  97, 108, 105, 122, 101, 
-     40,  32, 114, 101, 102, 108, 
-    101,  99, 116,  40,  32, 110, 
-    111, 114, 109,  97, 108, 105, 
-    122, 101,  40,  32,  45, 108, 
+     32, 102, 108, 111,  97, 116, 
+     32, 102,  32,  61,  32, 100, 
+    111, 116,  40,  32, 105, 110, 
+    112, 117, 116,  46, 110, 111, 
+    114, 109,  97, 108,  44,  32, 
+    110, 111, 114, 109,  97, 108, 
+    105, 122, 101,  40,  32, 108, 
     105, 103, 104, 116,  68, 105, 
-    114,  32,  41,  44,  32, 105, 
-    110, 112, 117, 116,  46, 110, 
-    111, 114, 109,  97, 108,  32, 
-     41,  32,  41,  44,  32, 110, 
-    111, 114, 109,  97, 108, 105, 
-    122, 101,  40,  32,  75,  97, 
-    109, 101, 114,  97,  46, 107, 
-     80, 111, 115, 105, 116, 105, 
-    111, 110,  46, 120, 121, 122, 
-     32,  45,  32, 105, 110, 112, 
-    117, 116,  46, 119, 111, 114, 
-    108, 100,  80, 111, 115,  46, 
-    120, 121, 122,  32,  41,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
+    114,  32,  41,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
      32,  32,  32,  32, 105, 102, 
      40,  32, 102,  32,  62,  32, 
      48,  32,  41,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32, 115, 112, 101, 
-     99, 117, 108,  97, 114,  76, 
+     32,  32,  32,  32, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
     105, 103, 104, 116,  32,  43, 
      61,  32, 112, 111, 105, 110, 
     116,  76, 105, 103, 104, 116, 
@@ -1659,74 +1534,113 @@ const BYTE DX12PixelShaderBytes[] =
      32, 102,  97,  99, 116, 111, 
     114,  59,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-    125,  13,  10,  32,  32,  32, 
-     32, 125,  42,  47,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  52,  32, 109, 
-     97, 116, 101, 114, 105,  97, 
-    108,  67, 111, 108, 111, 114, 
-     32,  61,  32, 115, 104,  97, 
-    100, 101, 114,  84, 101, 120, 
-    116, 117, 114, 101,  46,  83, 
-     97, 109, 112, 108, 101,  40, 
-     32,  83,  97, 109, 112, 108, 
-    101,  84, 121, 112, 101,  44, 
+     32,  32,  32,  32, 102,  32, 
+     61,  32, 100, 111, 116,  40, 
+     32, 110, 111, 114, 109,  97, 
+    108, 105, 122, 101,  40,  32, 
+    114, 101, 102, 108, 101,  99, 
+    116,  40,  32, 110, 111, 114, 
+    109,  97, 108, 105, 122, 101, 
+     40,  32,  45, 108, 105, 103, 
+    104, 116,  68, 105, 114,  32, 
+     41,  44,  32, 105, 110, 112, 
+    117, 116,  46, 110, 111, 114, 
+    109,  97, 108,  32,  41,  32, 
+     41,  44,  32, 110, 111, 114, 
+    109,  97, 108, 105, 122, 101, 
+     40,  32,  75,  97, 109, 101, 
+    114,  97,  46, 107,  80, 111, 
+    115, 105, 116, 105, 111, 110, 
+     46, 120, 121, 122,  32,  45, 
      32, 105, 110, 112, 117, 116, 
-     46, 116, 101, 120,  32,  41, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     52,  32, 116, 101, 120, 116, 
-    117, 114, 101,  67, 111, 108, 
-    111, 114,  32,  61,  32, 115, 
-     97, 116, 117, 114,  97, 116, 
-    101,  40,  32, 109,  97, 116, 
-    101, 114, 105,  97, 108,  67, 
+     46, 119, 111, 114, 108, 100, 
+     80, 111, 115,  46, 120, 121, 
+    122,  32,  41,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32, 105, 102,  40,  32, 
+    102,  32,  62,  32,  48,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32, 115, 112, 101,  99, 117, 
+    108,  97, 114,  76, 105, 103, 
+    104, 116,  32,  43,  61,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  91, 
+     32, 105,  32,  93,  46,  99, 
     111, 108, 111, 114,  32,  42, 
-     32,  79,  98, 106, 101,  99, 
-    116,  46,  97, 109,  98, 105, 
-    101, 110, 116,  70,  97,  99, 
-    116, 111, 114,  32,  43,  32, 
-    102, 108, 111,  97, 116,  52, 
-     40,  32, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  46, 120,  44,  32, 
+     32, 102,  32,  42,  32, 102, 
+     97,  99, 116, 111, 114,  59, 
+     13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32, 125,  13, 
+     10,  32,  32,  32,  32, 125, 
+     42,  47,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  52,  32, 109,  97, 116, 
+    101, 114, 105,  97, 108,  67, 
+    111, 108, 111, 114,  32,  61, 
+     32, 115, 104,  97, 100, 101, 
+    114,  84, 101, 120, 116, 117, 
+    114, 101,  46,  83,  97, 109, 
+    112, 108, 101,  40,  32,  83, 
+     97, 109, 112, 108, 101,  84, 
+    121, 112, 101,  44,  32, 105, 
+    110, 112, 117, 116,  46, 116, 
+    101, 120,  32,  41,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  52,  32, 
+    116, 101, 120, 116, 117, 114, 
+    101,  67, 111, 108, 111, 114, 
+     32,  61,  32, 115,  97, 116, 
+    117, 114,  97, 116, 101,  40, 
+     32, 109,  97, 116, 101, 114, 
+    105,  97, 108,  67, 111, 108, 
+    111, 114,  32,  42,  32,  79, 
+     98, 106, 101,  99, 116,  46, 
+     97, 109,  98, 105, 101, 110, 
+    116,  70,  97,  99, 116, 111, 
+    114,  32,  43,  32, 102, 108, 
+    111,  97, 116,  52,  40,  32, 
     100, 105, 102, 102, 117, 115, 
     101,  76, 105, 103, 104, 116, 
-     46, 121,  44,  32, 100, 105, 
+     46, 120,  44,  32, 100, 105, 
     102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  46, 122, 
-     44,  32,  48,  32,  41,  32, 
-     42,  32,  79,  98, 106, 101, 
-     99, 116,  46, 100, 105, 102, 
-    102, 117, 115,  70,  97,  99, 
-    116, 111, 114,  32,  43,  32, 
-    102, 108, 111,  97, 116,  52, 
-     40,  32, 115, 112, 101,  99, 
-    117, 108,  97, 114,  76, 105, 
-    103, 104, 116,  46, 120,  44, 
-     32, 115, 112, 101,  99, 117, 
-    108,  97, 114,  76, 105, 103, 
-    104, 116,  46, 121,  44,  32, 
+    105, 103, 104, 116,  46, 121, 
+     44,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  46, 122,  44,  32, 
+     48,  32,  41,  32,  42,  32, 
+     79,  98, 106, 101,  99, 116, 
+     46, 100, 105, 102, 102, 117, 
+    115,  70,  97,  99, 116, 111, 
+    114,  32,  43,  32, 102, 108, 
+    111,  97, 116,  52,  40,  32, 
     115, 112, 101,  99, 117, 108, 
      97, 114,  76, 105, 103, 104, 
-    116,  46, 122,  44,  32,  48, 
-     32,  41,  32,  42,  32,  79, 
-     98, 106, 101,  99, 116,  46, 
-    115, 112, 101,  99, 117, 108, 
-     97, 114,  70,  97,  99, 116, 
-    111, 114,  32,  41,  59,  13, 
-     10,  32,  32,  32,  32, 116, 
-    101, 120, 116, 117, 114, 101, 
-     67, 111, 108, 111, 114,  46, 
-     97,  32,  61,  32, 109,  97, 
-    116, 101, 114, 105,  97, 108, 
-     67, 111, 108, 111, 114,  46, 
-     97,  59,  13,  10,  32,  32, 
-     32,  32, 114, 101, 116, 117, 
-    114, 110,  32, 116, 101, 120, 
+    116,  46, 120,  44,  32, 115, 
+    112, 101,  99, 117, 108,  97, 
+    114,  76, 105, 103, 104, 116, 
+     46, 121,  44,  32, 115, 112, 
+    101,  99, 117, 108,  97, 114, 
+     76, 105, 103, 104, 116,  46, 
+    122,  44,  32,  48,  32,  41, 
+     32,  42,  32,  79,  98, 106, 
+    101,  99, 116,  46, 115, 112, 
+    101,  99, 117, 108,  97, 114, 
+     70,  97,  99, 116, 111, 114, 
+     32,  41,  59,  13,  10,  32, 
+     32,  32,  32, 116, 101, 120, 
     116, 117, 114, 101,  67, 111, 
-    108, 111, 114,  59,  13,  10, 
-    125,   0,   0,   0,   0,   0, 
+    108, 111, 114,  46,  97,  32, 
+     61,  32, 109,  97, 116, 101, 
+    114, 105,  97, 108,  67, 111, 
+    108, 111, 114,  46,  97,  59, 
+     13,  10,  32,  32,  32,  32, 
+    114, 101, 116, 117, 114, 110, 
+     32, 116, 101, 120, 116, 117, 
+    114, 101,  67, 111, 108, 111, 
+    114,  59,  13,  10, 125,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1786,40 +1700,40 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 254, 239, 
-    254, 239,   1,   0,   0,   0, 
-     62,  15,   0,   0,   0,  67, 
-     58,  92,  85, 115, 101, 114, 
-    115,  92, 107, 111, 108, 106, 
-     97,  92,  68, 101, 115, 107, 
-    116, 111, 112,  92,  75, 111, 
-    108, 106,  97,  45,  83, 116, 
-    114, 111, 104, 109,  45,  71, 
-     97, 109, 101, 115,  92,  65, 
-    108, 108, 103, 101, 109, 101, 
-    105, 110,  92,  70, 114,  97, 
-    109, 101, 119, 111, 114, 107, 
-     92,  68,  88,  49,  50,  80, 
-    105, 120, 101, 108,  83, 104, 
-     97, 100, 101, 114,  46, 104, 
-    108, 115, 108,   0,   0,  99, 
-     58,  92, 117, 115, 101, 114, 
-    115,  92, 107, 111, 108, 106, 
-     97,  92, 100, 101, 115, 107, 
-    116, 111, 112,  92, 107, 111, 
-    108, 106,  97,  45, 115, 116, 
-    114, 111, 104, 109,  45, 103, 
-     97, 109, 101, 115,  92,  97, 
-    108, 108, 103, 101, 109, 101, 
-    105, 110,  92, 102, 114,  97, 
-    109, 101, 119, 111, 114, 107, 
-     92, 100, 120,  49,  50, 112, 
-    105, 120, 101, 108, 115, 104, 
-     97, 100, 101, 114,  46, 104, 
-    108, 115, 108,   0,  47,  47, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0, 254, 239, 254, 239, 
+      1,   0,   0,   0,  62,  15, 
+      0,   0,   0,  67,  58,  92, 
+     85, 115, 101, 114, 115,  92, 
+    107, 111, 108, 106,  97,  92, 
+     68, 101, 115, 107, 116, 111, 
+    112,  92,  75, 111, 108, 106, 
+     97,  45,  83, 116, 114, 111, 
+    104, 109,  45,  71,  97, 109, 
+    101, 115,  92,  65, 108, 108, 
+    103, 101, 109, 101, 105, 110, 
+     92,  70, 114,  97, 109, 101, 
+    119, 111, 114, 107,  92,  68, 
+     88,  49,  50,  80, 105, 120, 
+    101, 108,  83, 104,  97, 100, 
+    101, 114,  46, 104, 108, 115, 
+    108,   0,   0,  99,  58,  92, 
+    117, 115, 101, 114, 115,  92, 
+    107, 111, 108, 106,  97,  92, 
+    100, 101, 115, 107, 116, 111, 
+    112,  92, 107, 111, 108, 106, 
+     97,  45, 115, 116, 114, 111, 
+    104, 109,  45, 103,  97, 109, 
+    101, 115,  92,  97, 108, 108, 
+    103, 101, 109, 101, 105, 110, 
+     92, 102, 114,  97, 109, 101, 
+    119, 111, 114, 107,  92, 100, 
+    120,  49,  50, 112, 105, 120, 
+    101, 108, 115, 104,  97, 100, 
+    101, 114,  46, 104, 108, 115, 
+    108,   0,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  32, 
-     32,  32,  32,  32,  32,  32, 
+     47,  47,  47,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1834,9 +1748,10 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  32,  71, 
-     76,  79,  66,  65,  76,  83, 
-     32,  47,  47,  32,  32,  32, 
+     32,  32,  32,  32,  13,  10, 
+     47,  47,  32,  71,  76,  79, 
+     66,  65,  76,  83,  32,  47, 
+     47,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1851,10 +1766,9 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     47,  47,  47,  47,  47,  47, 
+     32,  32,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  32,  32,  32,  32,  32, 
+     47,  47,  47,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1869,12 +1783,13 @@ const BYTE DX12PixelShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  84, 101, 
-    120, 116, 117, 114, 101,  50, 
-     68,  32, 115, 104,  97, 100, 
-     27, 226,  48,   1, 128,   0, 
-      0,   0,  83, 117, 131, 234, 
-    188, 227, 219,   1,   1,   0, 
+     32,  32,  32,  32,  32,  32, 
+     13,  10,  84, 101, 120, 116, 
+    117, 114, 101,  50,  68,  32, 
+    115, 104,  97, 100,  27, 226, 
+     48,   1, 128,   0,   0,   0, 
+     40, 195,  69,  59, 166,  22, 
+    220,   1,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1882,15 +1797,16 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
+      2,   0,   0,   0,   1,   0, 
       0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
+      0,   0,   0,   0,  85,   0, 
+      0,   0,  40,   0,   0,   0, 
+     27, 226,  48,   1,  93, 204, 
+     68, 139, 149,  14,   0,   0, 
+      1,   0,   0,   0,  84,   0, 
+      0,   0,  85,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     85,   0,   0,   0,  40,   0, 
-      0,   0,  27, 226,  48,   1, 
-     93, 204,  68, 139, 149,  14, 
-      0,   0,   1,   0,   0,   0, 
-     84,   0,   0,   0,  85,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1956,193 +1872,167 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      4,   0,   0,   0,  66,   0, 
+     60,  17,  16,   1,   0,   0, 
+      0,   1,  10,   0,   1,   0, 
+     46,  18, 244, 101,  10,   0, 
+      1,   0,  46,  18, 244, 101, 
+     77, 105,  99, 114, 111, 115, 
+    111, 102, 116,  32,  40,  82, 
+     41,  32,  72,  76,  83,  76, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  67, 111, 109, 112, 
+    105, 108, 101, 114,  32,  49, 
+     48,  46,  49,   0,   0,   0, 
+     54,   0,  61,  17,   1, 104, 
+    108, 115, 108,  70, 108,  97, 
+    103, 115,   0,  48, 120,  53, 
+      0, 104, 108, 115, 108,  84, 
+     97, 114, 103, 101, 116,   0, 
+    112, 115,  95,  53,  95,  49, 
+      0, 104, 108, 115, 108,  69, 
+    110, 116, 114, 121,   0, 109, 
+     97, 105, 110,   0,   0,   0, 
+      0,   0,  42,   0,  16,  17, 
+      0,   0,   0,   0, 216,   4, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   4,   0,   0,   0, 
-     66,   0,  60,  17,  16,   1, 
-      0,   0,   0,   1,  10,   0, 
-      1,   0,  76,  15, 244, 101, 
-     10,   0,   1,   0,  76,  15, 
-    244, 101,  77, 105,  99, 114, 
-    111, 115, 111, 102, 116,  32, 
-     40,  82,  41,  32,  72,  76, 
-     83,  76,  32,  83, 104,  97, 
-    100, 101, 114,  32,  67, 111, 
-    109, 112, 105, 108, 101, 114, 
-     32,  49,  48,  46,  49,   0, 
-      0,   0,  54,   0,  61,  17, 
-      1, 104, 108, 115, 108,  70, 
-    108,  97, 103, 115,   0,  48, 
-    120,  53,   0, 104, 108, 115, 
-    108,  84,  97, 114, 103, 101, 
-    116,   0, 112, 115,  95,  53, 
-     95,  49,   0, 104, 108, 115, 
-    108,  69, 110, 116, 114, 121, 
-      0, 109,  97, 105, 110,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,  17,   0,   0,   0,   0, 
-    216,   4,   0,   0,   0,   0, 
+    160,   1,   0,   0,   0,   0, 
       0,   0, 160,   1,   0,   0, 
-      0,   0,   0,   0, 160,   1, 
-      0,   0,   7,  16,   0,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160, 109,  97, 105, 110,   0, 
-     46,   0,  62,  17,   4,  16, 
-      0,   0,   9,   0, 105, 110, 
-    112, 117, 116,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+      7,  16,   0,   0, 124,   0, 
+      0,   0,   1,   0, 160, 109, 
+     97, 105, 110,   0,  46,   0, 
+     62,  17,   4,  16,   0,   0, 
+      9,   0, 105, 110, 112, 117, 
+    116,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   0,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   4,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   4,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   8,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   8,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  12,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  12,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  16,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  16,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  20,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  20,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  24,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  24,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  28,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  28,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  32,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  32,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  36,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  36,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  40,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  48,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  44,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  52,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  48,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  56,   0,   0,   0, 
-     58,   0,  62,  17,   6,  16, 
-      0,   0, 136,   0,  60, 109, 
-     97, 105, 110,  32, 114, 101, 
-    116, 117, 114, 110,  32, 118, 
-     97, 108, 117, 101,  62,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   0,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   4,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   4,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   8,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,   8,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  12,   0,   4,   0, 
-    124,   0,   0,   0,   1,   0, 
-    160,   1,  12,   0,   0,   0, 
-     50,   0,  62,  17,   2,  16, 
-      0,   0,   8,   0, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      0,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      4,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      8,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     12,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     12,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     16,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     20,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     24,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     24,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     28,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     28,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     32,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     32,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     36,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     36,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     40,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     48,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     44,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     52,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     48,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     56,   0,   0,   0,  58,   0, 
+     62,  17,   6,  16,   0,   0, 
+    136,   0,  60, 109,  97, 105, 
+    110,  32, 114, 101, 116, 117, 
+    114, 110,  32, 118,  97, 108, 
+    117, 101,  62,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 156,   0, 
-      0,   0,   1,   0, 148,   0, 
+     80,  17,   2,   0,   5,   0, 
+      0,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
       0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0, 156,   0, 
-      0,   0,   1,   0, 148,   0, 
+     80,  17,   2,   0,   5,   0, 
+      4,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
       4,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0, 156,   0, 
-      0,   0,   1,   0, 148,   0, 
-      8,   0,   0,   0,  54,   0, 
+     80,  17,   2,   0,   5,   0, 
+      8,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     12,   0,   4,   0, 124,   0, 
+      0,   0,   1,   0, 160,   1, 
+     12,   0,   0,   0,  50,   0, 
      62,  17,   2,  16,   0,   0, 
-      8,   0, 115, 112, 101,  99, 
-    117, 108,  97, 114,  76, 105, 
-    103, 104, 116,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-    188,   0,   0,   0,   1,   0, 
-    180,   0,  16,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-    188,   0,   0,   0,   1,   0, 
-    180,   0,  20,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-    188,   0,   0,   0,   1,   0, 
-    180,   0,  24,   0,   0,   0, 
-     54,   0,  62,  17,   0,  16, 
-      0,   0,   8,   0, 109,  97, 
-    116, 101, 114, 105,  97, 108, 
-     67, 111, 108, 111, 114,   0, 
-      0,   0,   0,   0,   0,   0, 
+      8,   0, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
       0,   0,   5,   0,   0,   0, 
-      4,   0, 232,   0,   0,   0, 
-      1,   0,  36,   0,  32,   0, 
+      4,   0, 156,   0,   0,   0, 
+      1,   0, 148,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
       0,   0,   5,   0,   4,   0, 
-      4,   0, 232,   0,   0,   0, 
-      1,   0,  36,   0,  36,   0, 
+      4,   0, 156,   0,   0,   0, 
+      1,   0, 148,   0,   4,   0, 
       0,   0,  22,   0,  80,  17, 
       0,   0,   5,   0,   8,   0, 
-      4,   0, 232,   0,   0,   0, 
-      1,   0,  36,   0,  40,   0, 
-      0,   0,  22,   0,  80,  17, 
-      0,   0,   5,   0,  12,   0, 
-      4,   0, 232,   0,   0,   0, 
-      1,   0,  52,   1,  44,   0, 
-      0,   0,  50,   0,  62,  17, 
-      0,  16,   0,   0,   8,   0, 
-    116, 101, 120, 116, 117, 114, 
-    101,  67, 111, 108, 111, 114, 
+      4,   0, 156,   0,   0,   0, 
+      1,   0, 148,   0,   8,   0, 
+      0,   0,  54,   0,  62,  17, 
+      2,  16,   0,   0,   8,   0, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  76, 105, 103, 104, 
+    116,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      0,   0,   4,   0, 188,   0, 
+      0,   0,   1,   0, 180,   0, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      4,   0,   4,   0, 188,   0, 
+      0,   0,   1,   0, 180,   0, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      8,   0,   4,   0, 188,   0, 
+      0,   0,   1,   0, 180,   0, 
+     24,   0,   0,   0,  54,   0, 
+     62,  17,   0,  16,   0,   0, 
+      8,   0, 109,  97, 116, 101, 
+    114, 105,  97, 108,  67, 111, 
+    108, 111, 114,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2150,93 +2040,203 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
       5,   0,   0,   0,   4,   0, 
-    220,   1,   0,   0,   1,   0, 
-     64,   0,   0,   0,   0,   0, 
+    232,   0,   0,   0,   1,   0, 
+     36,   0,  32,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
       5,   0,   4,   0,   4,   0, 
-    220,   1,   0,   0,   1,   0, 
-     64,   0,   4,   0,   0,   0, 
+    232,   0,   0,   0,   1,   0, 
+     36,   0,  36,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
       5,   0,   8,   0,   4,   0, 
-    220,   1,   0,   0,   1,   0, 
-     64,   0,   8,   0,   0,   0, 
+    232,   0,   0,   0,   1,   0, 
+     36,   0,  40,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
       5,   0,  12,   0,   4,   0, 
-    240,   1,   0,   0,   1,   0, 
-     44,   0,  44,   0,   0,   0, 
-      2,   0,   6,   0, 244,   0, 
-      0,   0,  24,   0,   0,   0, 
-      1,   0,   0,   0,  16,   1, 
-    160, 149,  17,  16, 107, 217, 
-     70,   1,  90,  86,  79,  94, 
-    158,  84,  18, 160,   0,   0, 
-    242,   0,   0,   0, 104,   1, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   1,   0,  28,   2, 
-      0,   0,   0,   0,   0,   0, 
-     28,   0,   0,   0,  92,   1, 
-      0,   0, 124,   0,   0,   0, 
-     79,   0,   0, 128, 124,   0, 
-      0,   0,  79,   0,   0,   0, 
+    232,   0,   0,   0,   1,   0, 
+     52,   1,  44,   0,   0,   0, 
+     50,   0,  62,  17,   0,  16, 
+      0,   0,   8,   0, 116, 101, 
+    120, 116, 117, 114, 101,  67, 
+    111, 108, 111, 114,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      0,   0,   4,   0, 220,   1, 
+      0,   0,   1,   0,  64,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      4,   0,   4,   0, 220,   1, 
+      0,   0,   1,   0,  64,   0, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      8,   0,   4,   0, 220,   1, 
+      0,   0,   1,   0,  64,   0, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     12,   0,   4,   0, 240,   1, 
+      0,   0,   1,   0,  44,   0, 
+     44,   0,   0,   0,   2,   0, 
+      6,   0, 244,   0,   0,   0, 
+     24,   0,   0,   0,   1,   0, 
+      0,   0,  16,   1, 160, 149, 
+     17,  16, 107, 217,  70,   1, 
+     90,  86,  79,  94, 158,  84, 
+     18, 160,   0,   0, 242,   0, 
+      0,   0, 104,   1,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      1,   0,  28,   2,   0,   0, 
+      0,   0,   0,   0,  28,   0, 
+      0,   0,  92,   1,   0,   0, 
+    124,   0,   0,   0,  79,   0, 
+      0, 128, 124,   0,   0,   0, 
+     79,   0,   0,   0, 156,   0, 
+      0,   0,  80,   0,   0, 128, 
     156,   0,   0,   0,  80,   0, 
-      0, 128, 156,   0,   0,   0, 
-     80,   0,   0,   0, 188,   0, 
-      0,   0, 100,   0,   0, 128, 
-    188,   0,   0,   0, 100,   0, 
-      0,   0, 232,   0,   0,   0, 
-    101,   0,   0, 128, 232,   0, 
-      0,   0, 101,   0,   0,   0, 
-     12,   1,   0,   0, 101,   0, 
-      0, 128,  12,   1,   0,   0, 
-    101,   0,   0,   0,  48,   1, 
+      0,   0, 188,   0,   0,   0, 
+    100,   0,   0, 128, 188,   0, 
+      0,   0, 100,   0,   0,   0, 
+    232,   0,   0,   0, 101,   0, 
+      0, 128, 232,   0,   0,   0, 
+    101,   0,   0,   0,  12,   1, 
       0,   0, 101,   0,   0, 128, 
-     48,   1,   0,   0, 101,   0, 
-      0,   0,  76,   1,   0,   0, 
-    101,   0,   0, 128,  76,   1, 
+     12,   1,   0,   0, 101,   0, 
+      0,   0,  48,   1,   0,   0, 
+    101,   0,   0, 128,  48,   1, 
       0,   0, 101,   0,   0,   0, 
-    112,   1,   0,   0, 101,   0, 
-      0, 128, 112,   1,   0,   0, 
-    101,   0,   0,   0, 140,   1, 
+     76,   1,   0,   0, 101,   0, 
+      0, 128,  76,   1,   0,   0, 
+    101,   0,   0,   0, 112,   1, 
       0,   0, 101,   0,   0, 128, 
-    140,   1,   0,   0, 101,   0, 
-      0,   0, 180,   1,   0,   0, 
-    101,   0,   0, 128, 180,   1, 
+    112,   1,   0,   0, 101,   0, 
+      0,   0, 140,   1,   0,   0, 
+    101,   0,   0, 128, 140,   1, 
       0,   0, 101,   0,   0,   0, 
+    180,   1,   0,   0, 101,   0, 
+      0, 128, 180,   1,   0,   0, 
+    101,   0,   0,   0, 220,   1, 
+      0,   0, 102,   0,   0, 128, 
     220,   1,   0,   0, 102,   0, 
-      0, 128, 220,   1,   0,   0, 
-    102,   0,   0,   0, 240,   1, 
-      0,   0, 103,   0,   0, 128, 
-    240,   1,   0,   0, 103,   0, 
-      0,   0,   4,   2,   0,   0, 
-    103,   0,   0, 128,   4,   2, 
+      0,   0, 240,   1,   0,   0, 
+    103,   0,   0, 128, 240,   1, 
       0,   0, 103,   0,   0,   0, 
+      4,   2,   0,   0, 103,   0, 
+      0, 128,   4,   2,   0,   0, 
+    103,   0,   0,   0,  24,   2, 
+      0,   0, 103,   0,   0, 128, 
      24,   2,   0,   0, 103,   0, 
-      0, 128,  24,   2,   0,   0, 
-    103,   0,   0,   0,   5,   0, 
-     44,   0,  27,   0,  43,   0, 
-      5,   0,  45,   0,  28,   0, 
-     44,   0,   5,   0,  73,   0, 
-     28,   0,  72,   0,   5,   0, 
-    248,   0,  37,   0,  72,   0, 
-      5,   0, 248,   0,  76,   0, 
-    156,   0,   5,   0, 248,   0, 
-     37,   0, 156,   0,   5,   0, 
-    248,   0, 160,   0, 245,   0, 
+      0,   0,   5,   0,  44,   0, 
+     27,   0,  43,   0,   5,   0, 
+     45,   0,  28,   0,  44,   0, 
+      5,   0,  73,   0,  28,   0, 
+     72,   0,   5,   0, 248,   0, 
+     37,   0,  72,   0,   5,   0, 
+    248,   0,  76,   0, 156,   0, 
       5,   0, 248,   0,  37,   0, 
-    245,   0,   5,   0, 248,   0, 
+    156,   0,   5,   0, 248,   0, 
+    160,   0, 245,   0,   5,   0, 
+    248,   0,  37,   0, 245,   0, 
+      5,   0, 248,   0,  27,   0, 
+    247,   0,   5,   0, 248,   0, 
      27,   0, 247,   0,   5,   0, 
-    248,   0,  27,   0, 247,   0, 
-      5,   0,  37,   0,   5,   0, 
-     36,   0,   5,   0,  24,   0, 
+     37,   0,   5,   0,  36,   0, 
       5,   0,  24,   0,   5,   0, 
      24,   0,   5,   0,  24,   0, 
       5,   0,  24,   0,   5,   0, 
-     24,   0, 246,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,   0,   0,   0,  20,   0, 
-      0,   0,  60,   0,   0,   0, 
-    100,   0,   0,   0,   0,   0, 
+     24,   0,   5,   0,  24,   0, 
+    246,   0,   0,   0,   4,   0, 
+      0,   0,   0,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,  20,   0,   0,   0, 
+     60,   0,   0,   0, 100,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  17,  16,   0,   0, 
+      1,   0,   0,   2,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2301,93 +2301,93 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,  11, 202, 
      49,   1,  56,   0,   0,   0, 
       0,  16,   0,   0,  19,  16, 
-      0,   0, 189,   1,   0,   0, 
-     11,   0, 255, 255,   4,   0, 
+      0,   0, 208,   1,   0,   0, 
+     10,   0, 255, 255,   4,   0, 
       0,   0, 255, 255,   3,   0, 
       0,   0,   0,   0,  76,   0, 
       0,   0,  76,   0,   0,   0, 
       8,   0,   0,   0,  84,   0, 
       0,   0,   0,   0,   0,   0, 
-     19,   0,  27,  21,  64,   0, 
+     22,   0,  27,  21,  64,   0, 
       0,   0,   4,   0,   0,   0, 
      16,   0, 102, 108, 111,  97, 
-    116,  52,   0,  19,   0,  27, 
-     21,  64,   0,   0,   0,   2, 
-      0,   0,   0,   8,   0, 102, 
-    108, 111,  97, 116,  50,   0, 
-     19,   0,  27,  21,  64,   0, 
+    116,  52,   0, 243, 242, 241, 
+     22,   0,  27,  21,  64,   0, 
+      0,   0,   2,   0,   0,   0, 
+      8,   0, 102, 108, 111,  97, 
+    116,  50,   0, 243, 242, 241, 
+     22,   0,  27,  21,  64,   0, 
       0,   0,   3,   0,   0,   0, 
      12,   0, 102, 108, 111,  97, 
-    116,  51,   0,  78,   0,   3, 
-     18,  13,  21,   3,   0,   0, 
-     16,   0,   0,   0,   0, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,   0, 241,  13,  21,   3, 
-      0,   0,  16,   0,   0,  16, 
-      0, 112, 111, 115, 105, 116, 
-    105, 111, 110,   0, 241,  13, 
-     21,   3,   0,   1,  16,   0, 
-      0,  32,   0, 116, 101, 120, 
-      0, 242, 241,  13,  21,   3, 
-      0,   2,  16,   0,   0,  40, 
-      0, 110, 111, 114, 109,  97, 
-    108,   0, 243, 242, 241,  35, 
-      0,   5,  21,   4,   0,   0, 
-      0,   3,  16,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  52,   0,  80, 105, 120, 
-    101, 108,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,   0, 
+    116,  51,   0, 243, 242, 241, 
+     78,   0,   3,  18,  13,  21, 
+      3,   0,   0,  16,   0,   0, 
+      0,   0, 119, 111, 114, 108, 
+    100,  80, 111, 115,   0, 241, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,  16,   0, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+      0, 241,  13,  21,   3,   0, 
+      1,  16,   0,   0,  32,   0, 
+    116, 101, 120,   0, 242, 241, 
+     13,  21,   3,   0,   2,  16, 
+      0,   0,  40,   0, 110, 111, 
+    114, 109,  97, 108,   0, 243, 
+    242, 241,  38,   0,   5,  21, 
+      4,   0,   0,   0,   3,  16, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  52,   0, 
+     80, 105, 120, 101, 108,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,   0, 243, 242, 241, 
      10,   0,   1,  18,   1,   0, 
       0,   0,   4,  16,   0,   0, 
      10,   0,  24,  21,   0,  16, 
       0,   0,   1,   0,   1,   0, 
      14,   0,   8,  16,   6,  16, 
       0,   0,  23,   0,   1,   0, 
-      5,  16,   0,   0,  12,   0, 
+      5,  16,   0,   0,  14,   0, 
      23,  21,   0,  16,   0,   0, 
       3,   2,   0,   0,   0,   0, 
-     10,   0,  24,  21,   8,  16, 
+    242, 241,  10,   0,  24,  21, 
+      8,  16,   0,   0,   1,   0, 
+      1,   0,  10,   0,  24,  21, 
+      9,  16,   0,   0,   1,   0, 
+      0,   2,  14,   0,  23,  21, 
+      0,   0,   0,   0,  10,   2, 
+      0,   0,   0,   0, 242, 241, 
+     10,   0,  24,  21,  11,  16, 
       0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,   9,  16, 
+     10,   0,  24,  21,  12,  16, 
       0,   0,   1,   0,   0,   2, 
-     12,   0,  23,  21,   0,   0, 
-      0,   0,  10,   2,   0,   0, 
-      0,   0,  10,   0,  24,  21, 
-     11,  16,   0,   0,   1,   0, 
-      1,   0,  10,   0,  24,  21, 
-     12,  16,   0,   0,   1,   0, 
-      0,   2,  78,   0,   3,  18, 
-     13,  21,   3,   0,  64,   0, 
-      0,   0,   0,   0,  97, 109, 
-     98, 105, 101, 110, 116,  70, 
-     97,  99, 116, 111, 114,   0, 
-     13,  21,   3,   0,  64,   0, 
-      0,   0,   4,   0, 100, 105, 
-    102, 102, 117, 115,  70,  97, 
-     99, 116, 111, 114,   0, 241, 
-     13,  21,   3,   0,  64,   0, 
-      0,   0,   8,   0, 115, 112, 
-    101,  99, 117, 108,  97, 114, 
-     70,  97,  99, 116, 111, 114, 
-      0, 243, 242, 241,  29,   0, 
-      5,  21,   3,   0,   0,   0, 
-     14,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     12,   0,  77,  97, 116, 101, 
-    114, 105,  97, 108,   0,  10, 
-      0,  24,  21,  15,  16,   0, 
-      0,   1,   0,   1,   0,  12, 
-      0,  23,  21,  16,  16,   0, 
-      0,  36,   2,  32, 216,   0, 
-      0,  10,   0,  24,  21,  17, 
-     16,   0,   0,   1,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
+     78,   0,   3,  18,  13,  21, 
+      3,   0,  64,   0,   0,   0, 
+      0,   0,  97, 109,  98, 105, 
+    101, 110, 116,  70,  97,  99, 
+    116, 111, 114,   0,  13,  21, 
+      3,   0,  64,   0,   0,   0, 
+      4,   0, 100, 105, 102, 102, 
+    117, 115,  70,  97,  99, 116, 
+    111, 114,   0, 241,  13,  21, 
+      3,   0,  64,   0,   0,   0, 
+      8,   0, 115, 112, 101,  99, 
+    117, 108,  97, 114,  70,  97, 
+     99, 116, 111, 114,   0, 243, 
+    242, 241,  30,   0,   5,  21, 
+      3,   0,   0,   0,  14,  16, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  12,   0, 
+     77,  97, 116, 101, 114, 105, 
+     97, 108,   0, 241,  10,   0, 
+     24,  21,  15,  16,   0,   0, 
+      1,   0,   1,   0,  14,   0, 
+     23,  21,  16,  16,   0,   0, 
+     36,   2, 240, 254,   0,   0, 
+    242, 241,  10,   0,  24,  21, 
      11, 202,  49,   1,  56,   0, 
       0,   0,   0,  16,   0,   0, 
       0,  16,   0,   0,   0,   0, 
-      0,   0,  13,   0, 255, 255, 
+      0,   0,  11,   0, 255, 255, 
       4,   0,   0,   0, 255, 255, 
       3,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3410,13 +3410,13 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
     255, 255, 255, 255, 119,   9, 
      49,   1,   1,   0,   0,   0, 
-     15,   0,  38, 142,  16,   0, 
-    116, 129,  17,   0, 100,   0, 
+     13,   0,  20, 142,  14,   0, 
+     20, 107,  15,   0,   1,   0, 
      76,   0,   0,   0,  32,   0, 
       0,   0,  44,   0,   0,   0, 
      96,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     24,   0,   0,   0,  25,   0, 
+     22,   0,   0,   0,  25,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   1,   0,   0,   0, 
@@ -3424,7 +3424,7 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,  32,   0,   0,  96, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      2,   0,  10,   0, 220,   4, 
+      2,   0,   9,   0, 220,   4, 
       0,   0,   0,   0,   0,   0, 
     156,   1,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3465,10 +3465,10 @@ const BYTE DX12PixelShaderBytes[] =
       0,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255,  14, 
+    255, 255, 255, 255, 255,  12, 
       0, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255, 255,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3494,51 +3494,42 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0, 148,  46,  49,   1, 
-      6, 118,  88, 104,   1,   0, 
-      0,   0, 129, 231, 186,  31, 
-    103, 104, 126,  69, 138, 219, 
-     59,  55, 121,  10, 174, 188, 
-    155,   0,   0,   0,  47,  76, 
+     76, 224, 173, 104,   1,   0, 
+      0,   0, 118,  43, 241, 153, 
+    212, 204,  58,  76, 157,  15, 
+     19, 216, 183, 230, 127, 195, 
+    128,   0,   0,   0,  47,  76, 
     105, 110, 107,  73, 110, 102, 
-    111,   0,  47,  84,  77,  67, 
-     97,  99, 104, 101,   0,  47, 
-    110,  97, 109, 101, 115,   0, 
-     47, 115, 114,  99,  47, 104, 
-    101,  97, 100, 101, 114,  98, 
-    108, 111,  99, 107,   0,  47, 
-    115, 114,  99,  47, 102, 105, 
-    108, 101, 115,  47,  99,  58, 
-     92, 117, 115, 101, 114, 115, 
-     92, 107, 111, 108, 106,  97, 
-     92, 100, 101, 115, 107, 116, 
-    111, 112,  92, 107, 111, 108, 
-    106,  97,  45, 115, 116, 114, 
-    111, 104, 109,  45, 103,  97, 
-    109, 101, 115,  92,  97, 108, 
-    108, 103, 101, 109, 101, 105, 
-    110,  92, 102, 114,  97, 109, 
-    101, 119, 111, 114, 107,  92, 
-    100, 120,  49,  50, 112, 105, 
-    120, 101, 108, 115, 104,  97, 
-    100, 101, 114,  46, 104, 108, 
-    115, 108,   0,  47,  85,  68, 
-     84,  83,  82,  67,  76,  73, 
-     78,  69,  85,  78,  68,  79, 
-     78,  69,   0,   6,   0,   0, 
-      0,  10,   0,   0,   0,   1, 
-      0,   0,   0,  63,   0,   0, 
-      0,   0,   0,   0,   0, 137, 
-      0,   0,   0,  12,   0,   0, 
-      0,  26,   0,   0,   0,   8, 
-      0,   0,   0,  43,   0,   0, 
-      0,   9,   0,   0,   0,   0, 
-      0,   0,   0,   5,   0,   0, 
-      0,  10,   0,   0,   0,   6, 
-      0,   0,   0,  19,   0,   0, 
-      0,   7,   0,   0,   0,   0, 
-      0,   0,   0, 220,  81,  51, 
-      1,   0,   0,   0,   0,   0, 
+    111,   0,  47, 110,  97, 109, 
+    101, 115,   0,  47, 115, 114, 
+     99,  47, 104, 101,  97, 100, 
+    101, 114,  98, 108, 111,  99, 
+    107,   0,  47, 115, 114,  99, 
+     47, 102, 105, 108, 101, 115, 
+     47,  99,  58,  92, 117, 115, 
+    101, 114, 115,  92, 107, 111, 
+    108, 106,  97,  92, 100, 101, 
+    115, 107, 116, 111, 112,  92, 
+    107, 111, 108, 106,  97,  45, 
+    115, 116, 114, 111, 104, 109, 
+     45, 103,  97, 109, 101, 115, 
+     92,  97, 108, 108, 103, 101, 
+    109, 101, 105, 110,  92, 102, 
+    114,  97, 109, 101, 119, 111, 
+    114, 107,  92, 100, 120,  49, 
+     50, 112, 105, 120, 101, 108, 
+    115, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
+      4,   0,   0,   0,   6,   0, 
+      0,   0,   1,   0,   0,   0, 
+     27,   0,   0,   0,   0,   0, 
+      0,   0,  34,   0,   0,   0, 
+      8,   0,   0,   0,  17,   0, 
+      0,   0,   7,   0,   0,   0, 
+     10,   0,   0,   0,   6,   0, 
       0,   0,   0,   0,   0,   0, 
+      5,   0,   0,   0,   0,   0, 
+      0,   0, 220,  81,  51,   1, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3578,41 +3569,50 @@ const BYTE DX12PixelShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  18,   0, 
-      0,   0,  40,   0,   0,   0, 
-      7,   1,   0,   0, 245,   1, 
-      0,   0, 105,   1,   0,   0, 
-     56,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    110,  15,   0,   0, 128,   0, 
-      0,   0, 149,  14,   0,   0, 
-    140,   6,   0,   0,  84,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  40,   0, 
-      0,   0,  68,   2,   0,   0, 
-     44,   0,   0,   0, 136,   0, 
-      0,   0,   7,   0,   0,   0, 
-     37,   0,   0,   0,  23,   0, 
-      0,   0,  36,   0,   0,   0, 
-     24,   0,   0,   0,  17,   0, 
-      0,   0,   3,   0,   0,   0, 
-     25,   0,   0,   0,  26,   0, 
-      0,   0,  27,   0,   0,   0, 
-     28,   0,   0,   0,  29,   0, 
-      0,   0,  30,   0,   0,   0, 
-     18,   0,   0,   0,   9,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  16,   0, 
+      0,   0,  32,   0,   0,   0, 
+    220,   0,   0,   0,   8,   2, 
+      0,   0, 103,   1,   0,   0, 
+     56,   0,   0,   0,   0,   0, 
+      0,   0, 110,  15,   0,   0, 
+    128,   0,   0,   0, 149,  14, 
+      0,   0, 140,   6,   0,   0, 
+     84,   0,   0,   0,   0,   0, 
+      0,   0,  40,   0,   0,   0, 
+     68,   2,   0,   0,  44,   0, 
+      0,   0, 136,   0,   0,   0, 
+      3,   0,   0,   0,  37,   0, 
+      0,   0,  23,   0,   0,   0, 
+     22,   0,   0,   0,  36,   0, 
+      0,   0,  24,   0,   0,   0, 
+     16,   0,   0,   0,   6,   0, 
+      0,   0,  25,   0,   0,   0, 
+     26,   0,   0,   0,  27,   0, 
+      0,   0,  28,   0,   0,   0, 
+     29,   0,   0,   0,  30,   0, 
+      0,   0,  17,   0,   0,   0, 
+      8,   0,   0,   0,   9,   0, 
       0,   0,  10,   0,   0,   0, 
      11,   0,   0,   0,  12,   0, 
       0,   0,  13,   0,   0,   0, 
      14,   0,   0,   0,  15,   0, 
-      0,   0,  16,   0,   0,   0, 
+      0,   0,  18,   0,   0,   0, 
      19,   0,   0,   0,  20,   0, 
       0,   0,  21,   0,   0,   0, 
-     22,   0,   0,   0,   4,   0, 
-      0,   0,  31,   0,   0,   0, 
-     32,   0,   0,   0,  33,   0, 
-      0,   0,  35,   0,   0,   0, 
-     34,   0,   0,   0,   0,   0, 
+      7,   0,   0,   0,  31,   0, 
+      0,   0,  32,   0,   0,   0, 
+     33,   0,   0,   0,  35,   0, 
+      0,   0,  34,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 

DX12VertexShader.h

@@ -131,10 +131,10 @@ ret
 
 const BYTE DX12VertexShaderBytes[] =
 {
-     68,  88,  66,  67, 216, 246, 
-    253, 166, 172,  38, 215, 244, 
-     30,   1,  17, 134,   1, 236, 
-    209, 140,   1,   0,   0,   0, 
+     68,  88,  66,  67, 235, 124, 
+    244, 211, 229,  59,  42, 225, 
+     43,  33, 223, 182, 217,  30, 
+    105, 165,   1,   0,   0,   0, 
     144,  78,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
     124,   2,   0,   0,  52,   3, 
@@ -502,10 +502,10 @@ const BYTE DX12VertexShaderBytes[] =
      77,  83,  70,  32,  55,  46, 
      48,  48,  13,  10,  26,  68, 
      83,   0,   0,   0,   0,   2, 
-      0,   0,   1,   0,   0,   0, 
-     35,   0,   0,   0, 184,   0, 
+      0,   0,   2,   0,   0,   0, 
+     35,   0,   0,   0, 176,   0, 
       0,   0,   0,   0,   0,   0, 
-     34,   0,   0,   0,   0,   0, 
+     33,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -581,8 +581,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 224,   1, 
-      0,   0, 248, 255, 255, 255, 
+      0,   0,   0,   0, 192, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -667,8 +666,8 @@ const BYTE DX12VertexShaderBytes[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-     24, 254, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
+     56,   0,   0,   0, 252, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -752,160 +751,13 @@ const BYTE DX12VertexShaderBytes[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    255, 255, 114, 117,  99, 116, 
-     32,  75,  97, 109, 101, 114, 
-     97,  66, 117, 102, 102, 101, 
-    114,  50,  13,  10, 123,  13, 
-     10,   9, 102, 108, 111,  97, 
-    116,  52,  32, 107,  80, 111, 
-    115, 105, 116, 105, 111, 110, 
-     59,  13,  10, 125,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-    116, 104, 101, 115, 101,  32, 
-    118,  97, 108, 117, 101, 115, 
-     32, 115, 104, 111, 117, 108, 
-    100,  32, 115, 117, 109,  32, 
-    117, 112,  32, 116, 111,  32, 
-     49,  13,  10, 115, 116, 114, 
-    117,  99, 116,  32,  77,  97, 
-    116, 101, 114, 105,  97, 108, 
-     13,  10, 123,  13,  10,   9, 
-    102, 108, 111,  97, 116,  32, 
-     97, 109,  98, 105, 101, 110, 
-    116,  70,  97,  99, 116, 111, 
-    114,  59,  13,  10,   9, 102, 
-    108, 111,  97, 116,  32, 100, 
-    105, 102, 102, 117, 115,  70, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  32, 115, 112, 101, 
-     99, 117, 108,  97, 114,  70, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10, 125,  59,  13,  10, 
-     13,  10, 115, 116, 114, 117, 
-     99, 116,  32,  76, 105, 103, 
-    104, 116,  67, 111, 117, 110, 
-    116,  13,  10, 123,  13,  10, 
-      9, 105, 110, 116,  32, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  67, 
-    111, 117, 110, 116,  59,  13, 
-     10,   9, 105, 110, 116,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116,  67, 111, 
-    117, 110, 116,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
-     67, 111, 110, 115, 116,  97, 
-    110, 116,  66, 117, 102, 102, 
-    101, 114,  60,  75,  97, 109, 
-    101, 114,  97,  66, 117, 102, 
-    102, 101, 114,  62,  32,  75, 
-     97, 109, 101, 114,  97,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40,  98, 
-     48,  41,  59,  13,  10,  67, 
-    111, 110, 115, 116,  97, 110, 
-    116,  66, 117, 102, 102, 101, 
-    114,  60,  77,  97, 116, 114, 
-    105, 120,  66, 117, 102, 102, 
-    101, 114,  62,  32,  83, 107, 
-    101, 108, 101, 116, 116,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40,  98, 
-     49,  41,  59,  13,  10,  67, 
-    111, 110, 115, 116,  97, 110, 
-    116,  66, 117, 102, 102, 101, 
-    114,  60,  75,  97, 109, 101, 
-    114,  97,  66, 117, 102, 102, 
-    101, 114,  50,  62,  32,  75, 
-     97, 109, 101, 114,  97,  50, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     98,  50,  41,  59,  13,  10, 
-     67, 111, 110, 115, 116,  97, 
-    110, 116,  66, 117, 102, 102, 
-    101, 114,  60,  77,  97, 116, 
-    101, 114, 105,  97, 108,  62, 
-     32,  79,  98, 106, 101,  99, 
-    116,  32,  58,  32, 114, 101, 
-    103, 105, 115, 116, 101, 114, 
-     40,  98,  51,  41,  59,  13, 
-     10,  67, 111, 110, 115, 116, 
-     97, 110, 116,  66, 117, 102, 
-    102, 101, 114,  60,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  62,  32,  76, 105, 
-    103, 104, 116,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  98, 165, 207, 
-      1,   0, 197,  74,   0,   0, 
-    102,  96,   2,   0, 146, 183, 
-      2,   0,  38, 247,   2,   0, 
-     14, 219,   3,   0,   4,  71, 
-      2,   0,  43, 236,   3,   0, 
-    217,  42,   2,   0,  18,  44, 
-      0,   0, 103, 159,   1,   0, 
-    179, 120,   1,   0, 238,  97, 
-      2,   0,  90,  28,   0,   0, 
-    219,  44,   3,   0,  53, 174, 
-      3,   0, 215,  46,   1,   0, 
-    193, 205,   3,   0, 207, 193, 
-      1,   0,  62,   3,   3,   0, 
-     56, 253,   1,   0, 118, 199, 
-      0,   0,   0,  16,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255, 255, 255, 
+    255, 255,   5,   0,   0,   0, 
+     32,   0,   0,   0,  60,   0, 
       0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0,   6,   0,   0,   0, 
+      5,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -923,16 +775,9 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1,   6, 118, 
-     88, 104,   1,   0,   0,   0, 
-     99, 131, 128, 156,  91, 251, 
-     24,  64, 189, 242,  78, 185, 
-    252, 184, 237,  55,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 220,  81,  51,   1, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -992,6 +837,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   3,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1008,10 +854,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-    119,   9,  49,   1,   0,   0, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1081,9 +923,16 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    148,  46,  49,   1,  77, 224, 
+    173, 104,   1,   0,   0,   0, 
+    176,   6, 156, 218, 212, 106, 
+     53,  66, 145, 172, 152,  28, 
+     27, 101, 150, 163,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0, 220,  81,  51,   1, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1093,13 +942,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   6,   0, 
-      0,   0,  32,   0,   0,   0, 
-     60,   0,   0,   0,   0,   0, 
-      0,   0,  64,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   3,   0,   0,   0, 
-      5,   0,   0,   0,   6,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1165,6 +1008,107 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0, 114, 117,  99, 116, 
+     32,  75,  97, 109, 101, 114, 
+     97,  66, 117, 102, 102, 101, 
+    114,  50,  13,  10, 123,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  52,  32, 107,  80, 111, 
+    115, 105, 116, 105, 111, 110, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  47,  47,  32, 
+    116, 104, 101, 115, 101,  32, 
+    118,  97, 108, 117, 101, 115, 
+     32, 115, 104, 111, 117, 108, 
+    100,  32, 115, 117, 109,  32, 
+    117, 112,  32, 116, 111,  32, 
+     49,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  77,  97, 
+    116, 101, 114, 105,  97, 108, 
+     13,  10, 123,  13,  10,   9, 
+    102, 108, 111,  97, 116,  32, 
+     97, 109,  98, 105, 101, 110, 
+    116,  70,  97,  99, 116, 111, 
+    114,  59,  13,  10,   9, 102, 
+    108, 111,  97, 116,  32, 100, 
+    105, 102, 102, 117, 115,  70, 
+     97,  99, 116, 111, 114,  59, 
+     13,  10,   9, 102, 108, 111, 
+     97, 116,  32, 115, 112, 101, 
+     99, 117, 108,  97, 114,  70, 
+     97,  99, 116, 111, 114,  59, 
+     13,  10, 125,  59,  13,  10, 
+     13,  10, 115, 116, 114, 117, 
+     99, 116,  32,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,  13,  10, 123,  13,  10, 
+      9, 105, 110, 116,  32, 100, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  59,  13, 
+     10,   9, 105, 110, 116,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116,  67, 111, 
+    117, 110, 116,  59,  13,  10, 
+    125,  59,  13,  10,  13,  10, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116,  66, 117, 102, 102, 
+    101, 114,  60,  75,  97, 109, 
+    101, 114,  97,  66, 117, 102, 
+    102, 101, 114,  62,  32,  75, 
+     97, 109, 101, 114,  97,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40,  98, 
+     48,  41,  59,  13,  10,  67, 
+    111, 110, 115, 116,  97, 110, 
+    116,  66, 117, 102, 102, 101, 
+    114,  60,  77,  97, 116, 114, 
+    105, 120,  66, 117, 102, 102, 
+    101, 114,  62,  32,  83, 107, 
+    101, 108, 101, 116, 116,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40,  98, 
+     49,  41,  59,  13,  10,  67, 
+    111, 110, 115, 116,  97, 110, 
+    116,  66, 117, 102, 102, 101, 
+    114,  60,  75,  97, 109, 101, 
+    114,  97,  66, 117, 102, 102, 
+    101, 114,  50,  62,  32,  75, 
+     97, 109, 101, 114,  97,  50, 
+     32,  58,  32, 114, 101, 103, 
+    105, 115, 116, 101, 114,  40, 
+     98,  50,  41,  59,  13,  10, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116,  66, 117, 102, 102, 
+    101, 114,  60,  77,  97, 116, 
+    101, 114, 105,  97, 108,  62, 
+     32,  79,  98, 106, 101,  99, 
+    116,  32,  58,  32, 114, 101, 
+    103, 105, 115, 116, 101, 114, 
+     40,  98,  51,  41,  59,  13, 
+     10,  67, 111, 110, 115, 116, 
+     97, 110, 116,  66, 117, 102, 
+    102, 101, 114,  60,  76, 105, 
+    103, 104, 116,  67, 111, 117, 
+    110, 116,  62,  32,  76, 105, 
+    103, 104, 116,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40,  98,  76, 232, 
+      3,   0, 117, 131,   1,   0, 
+    102,  96,   2,   0, 146, 183, 
+      2,   0,  38, 247,   2,   0, 
+    198,  90,   0,   0,   4,  71, 
+      2,   0,  43, 236,   3,   0, 
+    217,  42,   2,   0,  18,  44, 
+      0,   0, 103, 159,   1,   0, 
+    179, 120,   1,   0, 238,  97, 
+      2,   0,  90,  28,   0,   0, 
+    226, 187,   3,   0,  53, 174, 
+      3,   0, 206,  21,   0,   0, 
+    193, 205,   3,   0, 207, 193, 
+      1,   0,  62,   3,   3,   0, 
+     18, 116,   1,   0, 118, 199, 
+      0,   0,   0,  16,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1179,7 +1123,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1236,239 +1179,210 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  13,  10,  84, 101, 
-    120, 116, 117, 114, 101,  50, 
-     68,  32, 115, 104,  97, 100, 
-    101, 114,  84, 101, 120, 116, 
-    117, 114, 101,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40, 116,  48,  41, 
-     59,  13,  10,  83,  97, 109, 
-    112, 108, 101, 114,  83, 116, 
-     97, 116, 101,  32,  83,  97, 
-    109, 112, 108, 101,  84, 121, 
-    112, 101,  32,  58,  32, 114, 
-    101, 103, 105, 115, 116, 101, 
-    114,  40, 115,  48,  41,  59, 
-     13,  10,  13,  10,  47,  47, 
-     32,  77,  97, 116, 114, 105, 
-    122, 101, 110,  32, 102, 252, 
-    114,  32, 100, 105, 101,  32, 
-    101, 105, 110, 122, 101, 108, 
-    110, 101, 110,  32,  75, 110, 
-    111,  99, 104, 101, 110,  32, 
-    100, 101, 115,  32,  77, 111, 
-    100, 101, 108, 108, 115,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  77,  97, 116, 114, 
-    105, 120,  66, 117, 102, 102, 
-    101, 114,  13,  10, 123,  13, 
-     10,   9, 109,  97, 116, 114, 
-    105, 120,  32, 107, 110, 111, 
-     99, 104, 101, 110,  77,  97, 
-    116, 114, 105, 120,  91,  49, 
-     50,  56,  93,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
-     47,  47,  32,  84, 104, 101, 
-     32, 112, 114, 111, 106, 101, 
-     99, 116, 105, 111, 110,  32, 
-     97, 110, 100,  32, 118, 105, 
-    101, 119,  32, 109,  97, 116, 
-    114, 105, 120,  13,  10, 115, 
+     13,  10,  84, 101, 120, 116, 
+    117, 114, 101,  50,  68,  32, 
+    115, 104,  97, 100, 101, 114, 
+     84, 101, 120, 116, 117, 114, 
+    101,  32,  58,  32, 114, 101, 
+    103, 105, 115, 116, 101, 114, 
+     40, 116,  48,  41,  59,  13, 
+     10,  83,  97, 109, 112, 108, 
+    101, 114,  83, 116,  97, 116, 
+    101,  32,  83,  97, 109, 112, 
+    108, 101,  84, 121, 112, 101, 
+     32,  58,  32, 114, 101, 103, 
+    105, 115, 116, 101, 114,  40, 
+    115,  48,  41,  59,  13,  10, 
+     13,  10,  47,  47,  32,  77, 
+     97, 116, 114, 105, 122, 101, 
+    110,  32, 102, 252, 114,  32, 
+    100, 105, 101,  32, 101, 105, 
+    110, 122, 101, 108, 110, 101, 
+    110,  32,  75, 110, 111,  99, 
+    104, 101, 110,  32, 100, 101, 
+    115,  32,  77, 111, 100, 101, 
+    108, 108, 115,  13,  10, 115, 
     116, 114, 117,  99, 116,  32, 
-     75,  97, 109, 101, 114,  97, 
+     77,  97, 116, 114, 105, 120, 
      66, 117, 102, 102, 101, 114, 
      13,  10, 123,  13,  10,   9, 
     109,  97, 116, 114, 105, 120, 
-     32, 118, 105, 101, 119,  59, 
-     13,  10,   9, 109,  97, 116, 
-    114, 105, 120,  32, 112, 114, 
-    111, 106, 101,  99, 116, 105, 
-    111, 110,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  47, 
-     47,  32,  84, 104, 101,  32, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  32, 111, 102,  32, 
-    116, 104, 101,  32, 107,  97, 
-    109, 101, 114,  97,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  75,  97, 109, 101, 114, 
-     97,  66, 117, 102, 102, 101, 
-    114,  50,  13,  10, 123,  13, 
-     10,   9, 102, 108, 111,  97, 
-    116,  52,  32, 107,  80, 111, 
-    115, 105, 116, 105, 111, 110, 
+     32, 107, 110, 111,  99, 104, 
+    101, 110,  77,  97, 116, 114, 
+    105, 120,  91,  49,  50,  56, 
+     93,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  47,  47, 
+     32,  84, 104, 101,  32, 112, 
+    114, 111, 106, 101,  99, 116, 
+    105, 111, 110,  32,  97, 110, 
+    100,  32, 118, 105, 101, 119, 
+     32, 109,  97, 116, 114, 105, 
+    120,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  75,  97, 
+    109, 101, 114,  97,  66, 117, 
+    102, 102, 101, 114,  13,  10, 
+    123,  13,  10,   9, 109,  97, 
+    116, 114, 105, 120,  32, 118, 
+    105, 101, 119,  59,  13,  10, 
+      9, 109,  97, 116, 114, 105, 
+    120,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
      59,  13,  10, 125,  59,  13, 
      10,  13,  10,  47,  47,  32, 
-    116, 104, 101, 115, 101,  32, 
-    118,  97, 108, 117, 101, 115, 
-     32, 115, 104, 111, 117, 108, 
-    100,  32, 115, 117, 109,  32, 
-    117, 112,  32, 116, 111,  32, 
-     49,  13,  10, 115, 116, 114, 
-    117,  99, 116,  32,  77,  97, 
-    116, 101, 114, 105,  97, 108, 
+     84, 104, 101,  32, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     32, 111, 102,  32, 116, 104, 
+    101,  32, 107,  97, 109, 101, 
+    114,  97,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  75, 
+     97, 109, 101, 114,  97,  66, 
+    117, 102, 102, 101, 114,  50, 
      13,  10, 123,  13,  10,   9, 
-    102, 108, 111,  97, 116,  32, 
-     97, 109,  98, 105, 101, 110, 
-    116,  70,  97,  99, 116, 111, 
-    114,  59,  13,  10,   9, 102, 
-    108, 111,  97, 116,  32, 100, 
-    105, 102, 102, 117, 115,  70, 
+    102, 108, 111,  97, 116,  52, 
+     32, 107,  80, 111, 115, 105, 
+    116, 105, 111, 110,  59,  13, 
+     10, 125,  59,  13,  10,  13, 
+     10,  47,  47,  32, 116, 104, 
+    101, 115, 101,  32, 118,  97, 
+    108, 117, 101, 115,  32, 115, 
+    104, 111, 117, 108, 100,  32, 
+    115, 117, 109,  32, 117, 112, 
+     32, 116, 111,  32,  49,  13, 
+     10, 115, 116, 114, 117,  99, 
+    116,  32,  77,  97, 116, 101, 
+    114, 105,  97, 108,  13,  10, 
+    123,  13,  10,   9, 102, 108, 
+    111,  97, 116,  32,  97, 109, 
+     98, 105, 101, 110, 116,  70, 
      97,  99, 116, 111, 114,  59, 
      13,  10,   9, 102, 108, 111, 
-     97, 116,  32, 115, 112, 101, 
-     99, 117, 108,  97, 114,  70, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10, 125,  59,  13,  10, 
-     13,  10, 115, 116, 114, 117, 
-     99, 116,  32,  76, 105, 103, 
-    104, 116,  67, 111, 117, 110, 
-    116,  13,  10, 123,  13,  10, 
-      9, 105, 110, 116,  32, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  67, 
-    111, 117, 110, 116,  59,  13, 
-     10,   9, 105, 110, 116,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116,  67, 111, 
-    117, 110, 116,  59,  13,  10, 
+     97, 116,  32, 100, 105, 102, 
+    102, 117, 115,  70,  97,  99, 
+    116, 111, 114,  59,  13,  10, 
+      9, 102, 108, 111,  97, 116, 
+     32, 115, 112, 101,  99, 117, 
+    108,  97, 114,  70,  97,  99, 
+    116, 111, 114,  59,  13,  10, 
     125,  59,  13,  10,  13,  10, 
-     67, 111, 110, 115, 116,  97, 
-    110, 116,  66, 117, 102, 102, 
-    101, 114,  60,  75,  97, 109, 
-    101, 114,  97,  66, 117, 102, 
-    102, 101, 114,  62,  32,  75, 
-     97, 109, 101, 114,  97,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40,  98, 
-     48,  41,  59,  13,  10,  67, 
-    111, 110, 115, 116,  97, 110, 
-    116,  66, 117, 102, 102, 101, 
-    114,  60,  77,  97, 116, 114, 
-    105, 120,  66, 117, 102, 102, 
-    101, 114,  62,  32,  83, 107, 
-    101, 108, 101, 116, 116,  32, 
+    115, 116, 114, 117,  99, 116, 
+     32,  76, 105, 103, 104, 116, 
+     67, 111, 117, 110, 116,  13, 
+     10, 123,  13,  10,   9, 105, 
+    110, 116,  32, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  67, 111, 117, 
+    110, 116,  59,  13,  10,   9, 
+    105, 110, 116,  32, 112, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  67, 111, 
+    110, 115, 116,  97, 110, 116, 
+     66, 117, 102, 102, 101, 114, 
+     60,  75,  97, 109, 101, 114, 
+     97,  66, 117, 102, 102, 101, 
+    114,  62,  32,  75,  97, 109, 
+    101, 114,  97,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40,  98,  48,  41, 
+     59,  13,  10,  67, 111, 110, 
+    115, 116,  97, 110, 116,  66, 
+    117, 102, 102, 101, 114,  60, 
+     77,  97, 116, 114, 105, 120, 
+     66, 117, 102, 102, 101, 114, 
+     62,  32,  83, 107, 101, 108, 
+    101, 116, 116,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40,  98,  49,  41, 
+     59,  13,  10,  67, 111, 110, 
+    115, 116,  97, 110, 116,  66, 
+    117, 102, 102, 101, 114,  60, 
+     75,  97, 109, 101, 114,  97, 
+     66, 117, 102, 102, 101, 114, 
+     50,  62,  32,  75,  97, 109, 
+    101, 114,  97,  50,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  98,  50, 
+     41,  59,  13,  10,  67, 111, 
+    110, 115, 116,  97, 110, 116, 
+     66, 117, 102, 102, 101, 114, 
+     60,  77,  97, 116, 101, 114, 
+    105,  97, 108,  62,  32,  79, 
+     98, 106, 101,  99, 116,  32, 
      58,  32, 114, 101, 103, 105, 
     115, 116, 101, 114,  40,  98, 
-     49,  41,  59,  13,  10,  67, 
+     51,  41,  59,  13,  10,  67, 
     111, 110, 115, 116,  97, 110, 
     116,  66, 117, 102, 102, 101, 
-    114,  60,  75,  97, 109, 101, 
-    114,  97,  66, 117, 102, 102, 
-    101, 114,  50,  62,  32,  75, 
-     97, 109, 101, 114,  97,  50, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     98,  50,  41,  59,  13,  10, 
-     67, 111, 110, 115, 116,  97, 
-    110, 116,  66, 117, 102, 102, 
-    101, 114,  60,  77,  97, 116, 
-    101, 114, 105,  97, 108,  62, 
-     32,  79,  98, 106, 101,  99, 
+    114,  60,  76, 105, 103, 104, 
+    116,  67, 111, 117, 110, 116, 
+     62,  32,  76, 105, 103, 104, 
     116,  32,  58,  32, 114, 101, 
     103, 105, 115, 116, 101, 114, 
-     40,  98,  51,  41,  59,  13, 
-     10,  67, 111, 110, 115, 116, 
-     97, 110, 116,  66, 117, 102, 
-    102, 101, 114,  60,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  62,  32,  76, 105, 
-    103, 104, 116,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  98,  52,  41, 
-     59,  13,  10,  13,  10, 115, 
-    116, 114, 117,  99, 116,  32, 
-     86, 101, 114, 116, 101, 120, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  13,  10, 123, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  51,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32,  58,  32,  80,  79,  83, 
-     73,  84,  73,  79,  78,  59, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  50,  32, 116, 101, 
-    120,  32,  58,  32,  84,  69, 
-     88,  67,  79,  79,  82,  68, 
-     59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  51,  32, 110, 
-    111, 114, 109,  97, 108,  32, 
-     58,  32,  78,  79,  82,  77, 
-     65,  76,  59,  13,  10,   9, 
-    117, 105, 110, 116,  32, 107, 
-    110, 111,  99, 104, 101, 110, 
-     32,  58,  32,  75,  78,  79, 
-     67,  72,  69,  78,  95,  73, 
-     68,  59,  13,  10,   9, 117, 
-    105, 110, 116,  32, 105, 100, 
-     32,  58,  32,  86,  69,  82, 
-     84,  69,  88,  95,  73,  68, 
-     59,  13,  10, 125,  59,  13, 
+     40,  98,  52,  41,  59,  13, 
      10,  13,  10, 115, 116, 114, 
-    117,  99, 116,  32,  80, 105, 
-    120, 101, 108,  73, 110, 112, 
-    117, 116,  84, 121, 112, 101, 
-     13,  10, 123,  13,  10,   9, 
-    102, 108, 111,  97, 116,  52, 
-     32, 119, 111, 114, 108, 100, 
-     80, 111, 115,  32,  58,  32, 
-     80,  79,  83,  73,  84,  73, 
-     79,  78,  59,  13,  10,   9, 
-    102, 108, 111,  97, 116,  52, 
-     32, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32,  58,  32, 
-     83,  86,  95,  80,  79,  83, 
-     73,  84,  73,  79,  78,  59, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  50,  32, 116, 101, 
-    120,  32,  58,  32,  84,  69, 
-     88,  67,  79,  79,  82,  68, 
-     59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  51,  32, 110, 
-    111, 114, 109,  97, 108,  32, 
-     58,  32,  78,  79,  82,  77, 
-     65,  76,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10,  80, 
-    105, 120, 101, 108,  73, 110, 
+    117,  99, 116,  32,  86, 101, 
+    114, 116, 101, 120,  73, 110, 
     112, 117, 116,  84, 121, 112, 
-    101,  32, 109,  97, 105, 110, 
-     40,  86, 101, 114, 116, 101, 
-    120,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  32, 105, 
-    110, 112, 117, 116,  41,  13, 
-     10, 123,  13,  10,   9,  47, 
-     47, 114, 101, 116, 117, 114, 
-    110,  32, 105, 110, 112, 117, 
-    116,  59,  32,  32,  32,  32, 
+    101,  13,  10, 123,  13,  10, 
+      9, 102, 108, 111,  97, 116, 
+     51,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32,  58, 
+     32,  80,  79,  83,  73,  84, 
+     73,  79,  78,  59,  13,  10, 
+      9, 102, 108, 111,  97, 116, 
+     50,  32, 116, 101, 120,  32, 
+     58,  32,  84,  69,  88,  67, 
+     79,  79,  82,  68,  59,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  51,  32, 110, 111, 114, 
+    109,  97, 108,  32,  58,  32, 
+     78,  79,  82,  77,  65,  76, 
+     59,  13,  10,   9, 117, 105, 
+    110, 116,  32, 107, 110, 111, 
+     99, 104, 101, 110,  32,  58, 
+     32,  75,  78,  79,  67,  72, 
+     69,  78,  95,  73,  68,  59, 
+     13,  10,   9, 117, 105, 110, 
+    116,  32, 105, 100,  32,  58, 
+     32,  86,  69,  82,  84,  69, 
+     88,  95,  73,  68,  59,  13, 
+     10, 125,  59,  13,  10,  13, 
+     10, 115, 116, 114, 117,  99, 
+    116,  32,  80, 105, 120, 101, 
+    108,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,  13,  10, 
+    123,  13,  10,   9, 102, 108, 
+    111,  97, 116,  52,  32, 119, 
+    111, 114, 108, 100,  80, 111, 
+    115,  32,  58,  32,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,   9, 102, 108, 
+    111,  97, 116,  52,  32, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  58,  32,  83,  86, 
+     95,  80,  79,  83,  73,  84, 
+     73,  79,  78,  59,  13,  10, 
+      9, 102, 108, 111,  97, 116, 
+     50,  32, 116, 101, 120,  32, 
+     58,  32,  84,  69,  88,  67, 
+     79,  79,  82,  68,  59,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  51,  32, 110, 111, 114, 
+    109,  97, 108,  32,  58,  32, 
+     78,  79,  82,  77,  65,  76, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10,  80, 105, 120, 
+    101, 108,  73, 110, 112, 117, 
+    116,  84, 121, 112, 101,  32, 
+    109,  97, 105, 110,  40,  86, 
+    101, 114, 116, 101, 120,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,  32, 105, 110, 112, 
+    117, 116,  41,  13,  10, 123, 
+     13,  10,   9,  47,  47, 114, 
+    101, 116, 117, 114, 110,  32, 
+    105, 110, 112, 117, 116,  59, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1479,221 +1393,272 @@ const BYTE DX12VertexShaderBytes[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  13, 
-     10,   9,  80, 105, 120, 101, 
-    108,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  32, 111, 
-    117, 116, 112, 117, 116,  59, 
-     13,  10,   9, 111, 117, 116, 
-    112, 117, 116,  46, 110, 111, 
-    114, 109,  97, 108,  32,  61, 
-     32, 110, 111, 114, 109,  97, 
-    108, 105, 122, 101,  40, 109, 
-    117, 108,  40, 105, 110, 112, 
-    117, 116,  46, 110, 111, 114, 
-    109,  97, 108,  44,  32,  40, 
-    102, 108, 111,  97, 116,  51, 
-    120,  51,  41,  83, 107, 101, 
-    108, 101, 116, 116,  46, 107, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  13,  10,   9, 
+     80, 105, 120, 101, 108,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,  32, 111, 117, 116, 
+    112, 117, 116,  59,  13,  10, 
+      9, 111, 117, 116, 112, 117, 
+    116,  46, 110, 111, 114, 109, 
+     97, 108,  32,  61,  32, 110, 
+    111, 114, 109,  97, 108, 105, 
+    122, 101,  40, 109, 117, 108, 
+     40, 105, 110, 112, 117, 116, 
+     46, 110, 111, 114, 109,  97, 
+    108,  44,  32,  40, 102, 108, 
+    111,  97, 116,  51, 120,  51, 
+     41,  83, 107, 101, 108, 101, 
+    116, 116,  46, 107, 110, 111, 
+     99, 104, 101, 110,  77,  97, 
+    116, 114, 105, 120,  91, 105, 
+    110, 112, 117, 116,  46, 107, 
     110, 111,  99, 104, 101, 110, 
-     77,  97, 116, 114, 105, 120, 
-     91, 105, 110, 112, 117, 116, 
-     46, 107, 110, 111,  99, 104, 
-    101, 110,  93,  41,  41,  59, 
-     13,  10,  13,  10,   9,  47, 
-     47,  32,  67, 104,  97, 110, 
-    103, 101,  32, 116, 104, 101, 
+     93,  41,  41,  59,  13,  10, 
+     13,  10,   9,  47,  47,  32, 
+     67, 104,  97, 110, 103, 101, 
+     32, 116, 104, 101,  32, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32, 118, 101,  99, 116, 
+    111, 114,  32, 116, 111,  32, 
+     98, 101,  32,  52,  32, 117, 
+    110, 105, 116, 115,  32, 102, 
+    111, 114,  32, 112, 114, 111, 
+    112, 101, 114,  32, 109,  97, 
+    116, 114, 105, 120,  32,  99, 
+     97, 108,  99, 117, 108,  97, 
+    116, 105, 111, 110, 115,  46, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  13,  10,   9, 
+    102, 108, 111,  97, 116,  52, 
      32, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32, 118, 101, 
-     99, 116, 111, 114,  32, 116, 
-    111,  32,  98, 101,  32,  52, 
-     32, 117, 110, 105, 116, 115, 
-     32, 102, 111, 114,  32, 112, 
-    114, 111, 112, 101, 114,  32, 
-    109,  97, 116, 114, 105, 120, 
-     32,  99,  97, 108,  99, 117, 
-    108,  97, 116, 105, 111, 110, 
-    115,  46,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  13, 
-     10,   9, 102, 108, 111,  97, 
-    116,  52,  32, 112, 111, 115, 
-    105, 116, 105, 111, 110,  32, 
-     61,  32, 102, 108, 111,  97, 
-    116,  52,  40, 105, 110, 112, 
-    117, 116,  46, 112, 111, 115, 
-    105, 116, 105, 111, 110,  46, 
-    120,  44,  32, 105, 110, 112, 
-    117, 116,  46, 112, 111, 115, 
-    105, 116, 105, 111, 110,  46, 
-    121,  44,  32, 105, 110, 112, 
-    117, 116,  46, 112, 111, 115, 
-    105, 116, 105, 111, 110,  46, 
-    122,  44,  32,  49,  46, 102, 
-     41,  59,  13,  10,   9,  47, 
-     47,  32,  83, 116, 111, 114, 
-    101,  32, 116, 104, 101,  32, 
-    116, 101, 120, 116, 117, 114, 
-    101,  32,  99, 111, 111, 114, 
-    100, 105, 110,  97, 116, 101, 
-    115,  32, 102, 111, 114,  32, 
-    116, 104, 101,  32, 112, 105, 
-    120, 101, 108,  32, 115, 104, 
-     97, 100, 101, 114,  46,  32, 
+    105, 111, 110,  32,  61,  32, 
+    102, 108, 111,  97, 116,  52, 
+     40, 105, 110, 112, 117, 116, 
+     46, 112, 111, 115, 105, 116, 
+    105, 111, 110,  46, 120,  44, 
+     32, 105, 110, 112, 117, 116, 
+     46, 112, 111, 115, 105, 116, 
+    105, 111, 110,  46, 121,  44, 
+     32, 105, 110, 112, 117, 116, 
+     46, 112, 111, 115, 105, 116, 
+    105, 111, 110,  46, 122,  44, 
+     32,  49,  46, 102,  41,  59, 
+     13,  10,   9,  47,  47,  32, 
+     83, 116, 111, 114, 101,  32, 
+    116, 104, 101,  32, 116, 101, 
+    120, 116, 117, 114, 101,  32, 
+     99, 111, 111, 114, 100, 105, 
+    110,  97, 116, 101, 115,  32, 
+    102, 111, 114,  32, 116, 104, 
+    101,  32, 112, 105, 120, 101, 
+    108,  32, 115, 104,  97, 100, 
+    101, 114,  46,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  13, 
-     10,   9, 111, 117, 116, 112, 
-    117, 116,  46, 116, 101, 120, 
-     32,  61,  32, 105, 110, 112, 
-    117, 116,  46, 116, 101, 120, 
-     59,  13,  10,  13,  10,   9, 
-     47,  47,  32,  67,  97, 108, 
-     99, 117, 108,  97, 116, 101, 
-     32, 116, 104, 101,  32, 112, 
+     32,  32,  32,  13,  10,   9, 
+    111, 117, 116, 112, 117, 116, 
+     46, 116, 101, 120,  32,  61, 
+     32, 105, 110, 112, 117, 116, 
+     46, 116, 101, 120,  59,  13, 
+     10,  13,  10,   9,  47,  47, 
+     32,  67,  97, 108,  99, 117, 
+    108,  97, 116, 101,  32, 116, 
+    104, 101,  32, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+    111, 102,  32, 116, 104, 101, 
+     32, 118, 101, 114, 116, 101, 
+    120,  32,  97, 103,  97, 105, 
+    110, 115, 116,  32, 116, 104, 
+    101,  32, 119, 111, 114, 108, 
+    100,  44,  32, 118, 105, 101, 
+    119,  44,  32,  97, 110, 100, 
+     32, 112, 114, 111, 106, 101, 
+     99, 116, 105, 111, 110,  32, 
+    109,  97, 116, 114, 105,  99, 
+    101, 115,  46,  32,  13,  10, 
+      9, 111, 117, 116, 112, 117, 
+    116,  46, 119, 111, 114, 108, 
+    100,  80, 111, 115,  32,  61, 
+     32, 109, 117, 108,  40, 112, 
     111, 115, 105, 116, 105, 111, 
-    110,  32, 111, 102,  32, 116, 
-    104, 101,  32, 118, 101, 114, 
-    116, 101, 120,  32,  97, 103, 
-     97, 105, 110, 115, 116,  32, 
-    116, 104, 101,  32, 119, 111, 
-    114, 108, 100,  44,  32, 118, 
-    105, 101, 119,  44,  32,  97, 
-    110, 100,  32, 112, 114, 111, 
-    106, 101,  99, 116, 105, 111, 
-    110,  32, 109,  97, 116, 114, 
-    105,  99, 101, 115,  46,  32, 
-     13,  10,   9, 111, 117, 116, 
-    112, 117, 116,  46, 119, 111, 
-    114, 108, 100,  80, 111, 115, 
-     32,  61,  32, 109, 117, 108, 
-     40, 112, 111, 115, 105, 116, 
-    105, 111, 110,  44,  32,  83, 
-    107, 101, 108, 101, 116, 116, 
+    110,  44,  32,  83, 107, 101, 
+    108, 101, 116, 116,  46, 107, 
+    110, 111,  99, 104, 101, 110, 
+     77,  97, 116, 114, 105, 120, 
+     91, 105, 110, 112, 117, 116, 
      46, 107, 110, 111,  99, 104, 
-    101, 110,  77,  97, 116, 114, 
-    105, 120,  91, 105, 110, 112, 
-    117, 116,  46, 107, 110, 111, 
-     99, 104, 101, 110,  93,  41, 
-     59,  13,  10,   9, 111, 117, 
-    116, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  61,  32, 109, 117, 
-    108,  40, 111, 117, 116, 112, 
-    117, 116,  46, 119, 111, 114, 
-    108, 100,  80, 111, 115,  44, 
-     32,  75,  97, 109, 101, 114, 
-     97,  46, 118, 105, 101, 119, 
-     41,  59,  13,  10,   9, 111, 
-    117, 116, 112, 117, 116,  46, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  32,  61,  32, 109, 
-    117, 108,  40, 111, 117, 116, 
+    101, 110,  93,  41,  59,  13, 
+     10,   9, 111, 117, 116, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+     61,  32, 109, 117, 108,  40, 
+    111, 117, 116, 112, 117, 116, 
+     46, 119, 111, 114, 108, 100, 
+     80, 111, 115,  44,  32,  75, 
+     97, 109, 101, 114,  97,  46, 
+    118, 105, 101, 119,  41,  59, 
+     13,  10,   9, 111, 117, 116, 
     112, 117, 116,  46, 112, 111, 
     115, 105, 116, 105, 111, 110, 
-     44,  32,  75,  97, 109, 101, 
-    114,  97,  46, 112, 114, 111, 
+     32,  61,  32, 109, 117, 108, 
+     40, 111, 117, 116, 112, 117, 
+    116,  46, 112, 111, 115, 105, 
+    116, 105, 111, 110,  44,  32, 
+     75,  97, 109, 101, 114,  97, 
+     46, 112, 114, 111, 106, 101, 
+     99, 116, 105, 111, 110,  41, 
+     59,  13,  10,   9, 114, 101, 
+    116, 117, 114, 110,  32, 111, 
+    117, 116, 112, 117, 116,  59, 
+     13,  10, 125,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0, 254, 239, 254, 239, 
+      1,   0,   0,   0, 130,   8, 
+      0,   0,   0,  67,  58,  92, 
+     85, 115, 101, 114, 115,  92, 
+    107, 111, 108, 106,  97,  92, 
+     68, 101, 115, 107, 116, 111, 
+    112,  92,  75, 111, 108, 106, 
+     97,  45,  83, 116, 114, 111, 
+    104, 109,  45,  71,  97, 109, 
+    101, 115,  92,  65, 108, 108, 
+    103, 101, 109, 101, 105, 110, 
+     92,  70, 114,  97, 109, 101, 
+    119, 111, 114, 107,  92,  68, 
+     88,  49,  50,  86, 101, 114, 
+    116, 101, 120,  83, 104,  97, 
+    100, 101, 114,  46, 104, 108, 
+    115, 108,   0,   0,  99,  58, 
+     92, 117, 115, 101, 114, 115, 
+     92, 107, 111, 108, 106,  97, 
+     92, 100, 101, 115, 107, 116, 
+    111, 112,  92, 107, 111, 108, 
+    106,  97,  45, 115, 116, 114, 
+    111, 104, 109,  45, 103,  97, 
+    109, 101, 115,  92,  97, 108, 
+    108, 103, 101, 109, 101, 105, 
+    110,  92, 102, 114,  97, 109, 
+    101, 119, 111, 114, 107,  92, 
+    100, 120,  49,  50, 118, 101, 
+    114, 116, 101, 120, 115, 104, 
+     97, 100, 101, 114,  46, 104, 
+    108, 115, 108,   0,  13,  10, 
+     84, 101, 120, 116, 117, 114, 
+    101,  50,  68,  32, 115, 104, 
+     97, 100, 101, 114,  84, 101, 
+    120, 116, 117, 114, 101,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40, 116, 
+     48,  41,  59,  13,  10,  83, 
+     97, 109, 112, 108, 101, 114, 
+     83, 116,  97, 116, 101,  32, 
+     83,  97, 109, 112, 108, 101, 
+     84, 121, 112, 101,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40, 115,  48, 
+     41,  59,  13,  10,  13,  10, 
+     47,  47,  32,  77,  97, 116, 
+    114, 105, 122, 101, 110,  32, 
+    102, 252, 114,  32, 100, 105, 
+    101,  32, 101, 105, 110, 122, 
+    101, 108, 110, 101, 110,  32, 
+     75, 110, 111,  99, 104, 101, 
+    110,  32, 100, 101, 115,  32, 
+     77, 111, 100, 101, 108, 108, 
+    115,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  77,  97, 
+    116, 114, 105, 120,  66, 117, 
+    102, 102, 101, 114,  13,  10, 
+    123,  13,  10,   9, 109,  97, 
+    116, 114, 105, 120,  32, 107, 
+    110, 111,  99, 104, 101, 110, 
+     77,  97, 116, 114, 105, 120, 
+     91,  49,  50,  56,  93,  59, 
+     13,  10, 125,  59,  13,  10, 
+     13,  10,  47,  47,  32,  84, 
+    104, 101,  32, 112, 114, 111, 
     106, 101,  99, 116, 105, 111, 
-    110,  41,  59,  13,  10,   9, 
-    114, 101, 116, 117, 114, 110, 
-     32, 111, 117, 116, 112, 117, 
-    116,  59,  13,  10, 125,   0, 
+    110,  32,  97, 110, 100,  32, 
+    118, 105, 101, 119,  32, 109, 
+     97, 116, 114, 105, 120,  13, 
+     10, 115, 116, 114, 117,  99, 
+    116,  32,  75,  97, 109, 101, 
+    114,  97,  66, 117, 102, 102, 
+    101, 114,  13,  10, 123,  13, 
+     10,   9, 109,  97, 116, 114, 
+    105, 120,  32, 118, 105, 101, 
+    119,  59,  13,  10,   9, 109, 
+     97, 116, 114, 105, 120,  32, 
+    112, 114, 111, 106, 101,  99, 
+    116, 105, 111, 110,  59,  13, 
+     10, 125,  59,  13,  10,  13, 
+     10,  47,  47,  32,  84, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 111, 
+    102,  32, 116, 104, 101,  32, 
+    107,  97, 109, 101, 114,  97, 
+     13,  10, 115, 116,  27, 226, 
+     48,   1, 128,   0,   0,   0, 
+     40, 241,  94,  59, 166,  22, 
+    220,   1,   1,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      2,   0,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0,  86,   0, 
+      0,   0,  40,   0,   0,   0, 
+     27, 226,  48,   1, 152,  14, 
+     35,  73, 215,   7,   0,   0, 
+      1,   0,   0,   0,  85,   0, 
+      0,   0,  86,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 254, 239, 
-    254, 239,   1,   0,   0,   0, 
-    130,   8,   0,   0,   0,  67, 
-     58,  92,  85, 115, 101, 114, 
-    115,  92, 107, 111, 108, 106, 
-     97,  92,  68, 101, 115, 107, 
-    116, 111, 112,  92,  75, 111, 
-    108, 106,  97,  45,  83, 116, 
-    114, 111, 104, 109,  45,  71, 
-     97, 109, 101, 115,  92,  65, 
-    108, 108, 103, 101, 109, 101, 
-    105, 110,  92,  70, 114,  97, 
-    109, 101, 119, 111, 114, 107, 
-     92,  68,  88,  49,  50,  86, 
-    101, 114, 116, 101, 120,  83, 
-    104,  97, 100, 101, 114,  46, 
-    104, 108, 115, 108,   0,   0, 
-     99,  58,  92, 117, 115, 101, 
-    114, 115,  92, 107, 111, 108, 
-    106,  97,  92, 100, 101, 115, 
-    107, 116, 111, 112,  92, 107, 
-    111, 108, 106,  97,  45, 115, 
-    116, 114, 111, 104, 109,  45, 
-    103,  97, 109, 101, 115,  92, 
-     97, 108, 108, 103, 101, 109, 
-    101, 105, 110,  92, 102, 114, 
-     97, 109, 101, 119, 111, 114, 
-    107,  92, 100, 120,  49,  50, 
-    118, 101, 114, 116, 101, 120, 
-    115, 104,  97, 100, 101, 114, 
-     46, 104, 108, 115, 108,   0, 
-     13,  10,  84, 101, 120, 116, 
-    117, 114, 101,  50,  68,  32, 
-    115, 104,  97, 100, 101, 114, 
-     84, 101, 120, 116, 117, 114, 
-    101,  32,  58,  32, 114, 101, 
-    103, 105, 115, 116, 101, 114, 
-     40, 116,  48,  41,  59,  13, 
-     10,  83,  97, 109, 112, 108, 
-    101, 114,  83, 116,  97, 116, 
-    101,  32,  83,  97, 109, 112, 
-    108, 101,  84, 121, 112, 101, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-    115,  48,  41,  59,  13,  10, 
-     13,  10,  47,  47,  32,  77, 
-     97, 116, 114, 105, 122, 101, 
-    110,  32, 102, 252, 114,  32, 
-    100, 105, 101,  32, 101, 105, 
-    110, 122, 101, 108, 110, 101, 
-    110,  32,  75, 110, 111,  99, 
-    104, 101, 110,  32, 100, 101, 
-    115,  32,  77, 111, 100, 101, 
-    108, 108, 115,  13,  10, 115, 
-    116, 114, 117,  99, 116,  32, 
-     77,  97, 116, 114, 105, 120, 
-     66, 117, 102, 102, 101, 114, 
-     13,  10, 123,  13,  10,   9, 
-    109,  97, 116, 114, 105, 120, 
-     32, 107, 110, 111,  99, 104, 
-    101, 110,  77,  97, 116, 114, 
-    105, 120,  91,  49,  50,  56, 
-     93,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10,  47,  47, 
-     32,  84, 104, 101,  32, 112, 
-    114, 111, 106, 101,  99, 116, 
-    105, 111, 110,  32,  97, 110, 
-    100,  32, 118, 105, 101, 119, 
-     32, 109,  97, 116, 114, 105, 
-    120,  13,  10, 115, 116, 114, 
-    117,  99, 116,  32,  75,  97, 
-    109, 101, 114,  97,  66, 117, 
-    102, 102, 101, 114,  13,  10, 
-    123,  13,  10,   9, 109,  97, 
-    116, 114, 105, 120,  32, 118, 
-    105, 101, 119,  59,  13,  10, 
-      9, 109,  97, 116, 114, 105, 
-    120,  32, 112, 114, 111, 106, 
-    101,  99, 116, 105, 111, 110, 
-     59,  13,  10, 125,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-     84, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 111, 102,  32, 116, 104, 
-    101,  32, 107,  97, 109, 101, 
-    114,  97,  13,  10, 115, 116, 
-     27, 226,  48,   1, 128,   0, 
-      0,   0, 216,  97, 160, 234, 
-    188, 227, 219,   1,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1701,15 +1666,440 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      4,   0,   0,   0,  66,   0, 
+     60,  17,  16,   1,   0,   0, 
+      0,   1,  10,   0,   1,   0, 
+     46,  18, 244, 101,  10,   0, 
+      1,   0,  46,  18, 244, 101, 
+     77, 105,  99, 114, 111, 115, 
+    111, 102, 116,  32,  40,  82, 
+     41,  32,  72,  76,  83,  76, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  67, 111, 109, 112, 
+    105, 108, 101, 114,  32,  49, 
+     48,  46,  49,   0,   0,   0, 
+     54,   0,  61,  17,   1, 104, 
+    108, 115, 108,  70, 108,  97, 
+    103, 115,   0,  48, 120,  53, 
+      0, 104, 108, 115, 108,  84, 
+     97, 114, 103, 101, 116,   0, 
+    118, 115,  95,  53,  95,  49, 
+      0, 104, 108, 115, 108,  69, 
+    110, 116, 114, 121,   0, 109, 
+     97, 105, 110,   0,   0,   0, 
+      0,   0,  42,   0,  16,  17, 
+      0,   0,   0,   0, 152,   5, 
+      0,   0,   0,   0,   0,   0, 
+    104,   3,   0,   0,   0,   0, 
+      0,   0, 104,   3,   0,   0, 
+      9,  16,   0,   0, 176,   0, 
+      0,   0,   1,   0, 160, 109, 
+     97, 105, 110,   0,  46,   0, 
+     62,  17,   3,  16,   0,   0, 
+      9,   0, 105, 110, 112, 117, 
+    116,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      0,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      4,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      8,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     12,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     16,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     20,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     32,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     24,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     36,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     28,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     40,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     32,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     48,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     36,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     64,   0,   0,   0,  58,   0, 
+     62,  17,   8,  16,   0,   0, 
+    136,   0,  60, 109,  97, 105, 
+    110,  32, 114, 101, 116, 117, 
+    114, 110,  32, 118,  97, 108, 
+    117, 101,  62,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     40,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     48,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     44,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     52,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     48,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     56,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     32,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     32,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     36,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     36,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     16,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     20,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     24,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     24,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     28,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     28,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      0,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      4,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      8,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     12,   0,   4,   0, 176,   0, 
+      0,   0,   1,   0, 104,   3, 
+     12,   0,   0,   0,  46,   0, 
+     62,  17,   7,  16,   0,   0, 
+      8,   0, 111, 117, 116, 112, 
+    117, 116,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     40,   0,   4,   0, 156,   1, 
+      0,   0,   1,   0, 124,   2, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     44,   0,   4,   0, 156,   1, 
+      0,   0,   1,   0, 124,   2, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     48,   0,   4,   0, 156,   1, 
+      0,   0,   1,   0, 124,   2, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     32,   0,   4,   0, 216,   1, 
+      0,   0,   1,   0,  64,   2, 
+     32,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     36,   0,   4,   0, 216,   1, 
+      0,   0,   1,   0,  64,   2, 
+     36,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      0,   0,   4,   0,  32,   2, 
+      0,   0,   1,   0, 248,   1, 
+     48,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      4,   0,   4,   0,  76,   2, 
+      0,   0,   1,   0, 204,   1, 
+     52,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      8,   0,   4,   0, 120,   2, 
+      0,   0,   1,   0, 160,   1, 
+     56,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     12,   0,   4,   0, 164,   2, 
+      0,   0,   1,   0, 116,   1, 
+     60,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     16,   0,   4,   0, 200,   2, 
+      0,   0,   1,   0, 144,   0, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     20,   0,   4,   0, 236,   2, 
+      0,   0,   1,   0, 144,   0, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     24,   0,   4,   0,  16,   3, 
+      0,   0,   1,   0, 144,   0, 
+     24,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     28,   0,   4,   0,  52,   3, 
+      0,   0,   1,   0, 144,   0, 
+     28,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     16,   0,   4,   0,  88,   3, 
+      0,   0,   1,   0, 192,   0, 
+     64,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     20,   0,   4,   0, 124,   3, 
+      0,   0,   1,   0, 156,   0, 
+     68,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     24,   0,   4,   0, 160,   3, 
+      0,   0,   1,   0, 120,   0, 
+     72,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     28,   0,   4,   0, 196,   3, 
+      0,   0,   1,   0,  84,   0, 
+     76,   0,   0,   0,  46,   0, 
+     62,  17,   5,  16,   0,   0, 
+      8,   0, 112, 111, 115, 105, 
+    116, 105, 111, 110,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      0,   0,   4,   0, 176,   1, 
+      0,   0,   1,   0,  24,   1, 
+     16,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      4,   0,   4,   0, 176,   1, 
+      0,   0,   1,   0,  60,   1, 
+     20,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+      8,   0,   4,   0, 176,   1, 
+      0,   0,   1,   0,  96,   1, 
+     24,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   5,   0, 
+     12,   0,   4,   0, 196,   1, 
+      0,   0,   1,   0, 112,   1, 
+     28,   0,   0,   0,   2,   0, 
+      6,   0, 244,   0,   0,   0, 
+     24,   0,   0,   0,   1,   0, 
+      0,   0,  16,   1, 246, 167, 
+     61,  99, 243, 244,  18,  82, 
+    183, 159, 174,  72, 213, 136, 
+    161, 192,   0,   0, 242,   0, 
+      0,   0, 184,   2,   0,   0, 
       0,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
+      1,   0,  24,   4,   0,   0, 
+      0,   0,   0,   0,  56,   0, 
+      0,   0, 172,   2,   0,   0, 
+    176,   0,   0,   0,  65,   0, 
+      0, 128, 176,   0,   0,   0, 
+     65,   0,   0,   0, 208,   0, 
+      0,   0,  65,   0,   0, 128, 
+    208,   0,   0,   0,  65,   0, 
+      0,   0, 248,   0,   0,   0, 
+     65,   0,   0, 128, 248,   0, 
+      0,   0,  65,   0,   0,   0, 
+     36,   1,   0,   0,  65,   0, 
+      0, 128,  36,   1,   0,   0, 
+     65,   0,   0,   0,  80,   1, 
+      0,   0,  65,   0,   0, 128, 
+     80,   1,   0,   0,  65,   0, 
+      0,   0, 108,   1,   0,   0, 
+     65,   0,   0, 128, 108,   1, 
+      0,   0,  65,   0,   0,   0, 
+    128,   1,   0,   0,  65,   0, 
+      0, 128, 128,   1,   0,   0, 
+     65,   0,   0,   0, 156,   1, 
+      0,   0,  68,   0,   0, 128, 
+    156,   1,   0,   0,  68,   0, 
+      0,   0, 176,   1,   0,   0, 
+     68,   0,   0, 128, 176,   1, 
+      0,   0,  68,   0,   0,   0, 
+    196,   1,   0,   0,  70,   0, 
+      0, 128, 196,   1,   0,   0, 
+     70,   0,   0,   0, 216,   1, 
+      0,   0,  73,   0,   0, 128, 
+    216,   1,   0,   0,  73,   0, 
+      0,   0, 248,   1,   0,   0, 
+     73,   0,   0, 128, 248,   1, 
+      0,   0,  73,   0,   0,   0, 
+     32,   2,   0,   0,  73,   0, 
+      0, 128,  32,   2,   0,   0, 
+     73,   0,   0,   0,  76,   2, 
+      0,   0,  73,   0,   0, 128, 
+     76,   2,   0,   0,  73,   0, 
+      0,   0, 120,   2,   0,   0, 
+     73,   0,   0, 128, 120,   2, 
+      0,   0,  73,   0,   0,   0, 
+    164,   2,   0,   0,  74,   0, 
+      0, 128, 164,   2,   0,   0, 
+     74,   0,   0,   0, 200,   2, 
+      0,   0,  74,   0,   0, 128, 
+    200,   2,   0,   0,  74,   0, 
+      0,   0, 236,   2,   0,   0, 
+     74,   0,   0, 128, 236,   2, 
+      0,   0,  74,   0,   0,   0, 
+     16,   3,   0,   0,  74,   0, 
+      0, 128,  16,   3,   0,   0, 
+     74,   0,   0,   0,  52,   3, 
+      0,   0,  75,   0,   0, 128, 
+     52,   3,   0,   0,  75,   0, 
+      0,   0,  88,   3,   0,   0, 
+     75,   0,   0, 128,  88,   3, 
+      0,   0,  75,   0,   0,   0, 
+    124,   3,   0,   0,  75,   0, 
+      0, 128, 124,   3,   0,   0, 
+     75,   0,   0,   0, 160,   3, 
+      0,   0,  75,   0,   0, 128, 
+    160,   3,   0,   0,  75,   0, 
+      0,   0, 196,   3,   0,   0, 
+     76,   0,   0, 128, 196,   3, 
+      0,   0,  76,   0,   0,   0, 
+    216,   3,   0,   0,  76,   0, 
+      0, 128, 216,   3,   0,   0, 
+     76,   0,   0,   0, 236,   3, 
+      0,   0,  76,   0,   0, 128, 
+    236,   3,   0,   0,  76,   0, 
+      0,   0,   0,   4,   0,   0, 
+     76,   0,   0, 128,   0,   4, 
+      0,   0,  76,   0,   0,   0, 
+     20,   4,   0,   0,  76,   0, 
+      0, 128,  20,   4,   0,   0, 
+     76,   0,   0,   0,   2,   0, 
+     94,   0,  56,   0,  91,   0, 
+      2,   0,  94,   0,  28,   0, 
+     92,   0,   2,   0,  94,   0, 
+     28,   0,  92,   0,   2,   0, 
+     94,   0,  28,   0,  92,   0, 
+      2,   0,  94,   0,  18,   0, 
+     93,   0,   2,   0,  94,   0, 
+     18,   0,  93,   0,   2,   0, 
+     94,   0,  18,   0,  93,   0, 
+      2,   0,  85,   0,   9,   0, 
+     84,   0,   2,   0,  85,   0, 
+      9,   0,  84,   0,   2,   0, 
+     24,   0,   2,   0,  23,   0, 
+      2,   0,  71,   0,  34,   0, 
+     69,   0,   2,   0,  71,   0, 
+     20,   0,  70,   0,   2,   0, 
+     71,   0,  20,   0,  70,   0, 
+      2,   0,  71,   0,  20,   0, 
+     70,   0,   2,   0,  71,   0, 
+     20,   0,  70,   0,   2,   0, 
+     53,   0,  20,   0,  52,   0, 
+      2,   0,  53,   0,  20,   0, 
+     52,   0,   2,   0,  53,   0, 
+     20,   0,  52,   0,   2,   0, 
+     53,   0,  20,   0,  52,   0, 
+      2,   0,  59,   0,  20,   0, 
+     58,   0,   2,   0,  59,   0, 
+     20,   0,  58,   0,   2,   0, 
+     59,   0,  20,   0,  58,   0, 
+      2,   0,  59,   0,  20,   0, 
+     58,   0,   2,   0,  15,   0, 
+      2,   0,  15,   0,   2,   0, 
+     15,   0,   2,   0,  15,   0, 
+      2,   0,  15,   0,   2,   0, 
+     15,   0,   2,   0,  15,   0, 
+      2,   0,  15,   0,   2,   0, 
+     15,   0,   2,   0,  15,   0, 
+    246,   0,   0,   0,   4,   0, 
+      0,   0,   0,   0,   0,   0, 
+     12,   0,   0,   0,   0,   0, 
+      0,   0,  20,   0,   0,   0, 
+     56,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     86,   0,   0,   0,  40,   0, 
-      0,   0,  27, 226,  48,   1, 
-    152,  14,  35,  73, 215,   7, 
-      0,   0,   1,   0,   0,   0, 
-     85,   0,   0,   0,  86,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1729,6 +2119,38 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    128,   0,  75,  97, 109, 101, 
+    114,  97,  66, 117, 102, 102, 
+    101, 114,   0, 241,  10,   0, 
+     24,  21,  12,  16,   0,   0, 
+      1,   0,   1,   0,  14,   0, 
+     23,  21,  13,  16,   0,   0, 
+     36,   2,   0,   0,   0,   0, 
+    242, 241,  10,   0,  24,  21, 
+     14,  16,   0,   0,   1,   0, 
+      0,   2,  18,   0,  22,  21, 
+     10,  16,   0,   0,  34,   0, 
+      0,   0,   1,   0,   0,   0, 
+      0,   0,   0, 241,  26,   0, 
+      3,  18,  13,  21,   3,   0, 
+     16,  16,   0,   0,   0,   0, 
+    107, 110, 111,  99, 104, 101, 
+    110,  77,  97, 116, 114, 105, 
+    120,   0,  34,   0,   5,  21, 
+      1,   0,   0,   0,  17,  16, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,  32, 
+     77,  97, 116, 114, 105, 120, 
+     66, 117, 102, 102, 101, 114, 
+      0, 241,  10,   0,  24,  21, 
+     18,  16,   0,   0,   1,   0, 
+      1,   0,  14,   0,  23,  21, 
+     19,  16,   0,   0,  36,   2, 
+    128,  77,   0,   0, 242, 241, 
+     10,   0,  24,  21,  20,  16, 
+      0,   0,   1,   0,   0,   2, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1776,373 +2198,117 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     11, 202,  49,   1,  56,   0, 
+      0,   0,   0,  16,   0,   0, 
+     22,  16,   0,   0, 132,   2, 
+      0,   0,  10,   0, 255, 255, 
+      4,   0,   0,   0, 255, 255, 
+      3,   0,   0,   0,   0,   0, 
+     88,   0,   0,   0,  88,   0, 
+      0,   0,   8,   0,   0,   0, 
+     96,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  27,  21, 
+     64,   0,   0,   0,   3,   0, 
+      0,   0,  12,   0, 102, 108, 
+    111,  97, 116,  51,   0, 243, 
+    242, 241,  22,   0,  27,  21, 
+     64,   0,   0,   0,   2,   0, 
+      0,   0,   8,   0, 102, 108, 
+    111,  97, 116,  50,   0, 243, 
+    242, 241,  94,   0,   3,  18, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,   0,   0, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+      0, 241,  13,  21,   3,   0, 
+      1,  16,   0,   0,  12,   0, 
+    116, 101, 120,   0, 242, 241, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,  20,   0, 110, 111, 
+    114, 109,  97, 108,   0, 243, 
+    242, 241,  13,  21,   3,   0, 
+    117,   0,   0,   0,  32,   0, 
+    107, 110, 111,  99, 104, 101, 
+    110,   0, 242, 241,  13,  21, 
+      3,   0, 117,   0,   0,   0, 
+     36,   0, 105, 100,   0, 243, 
+    242, 241,  38,   0,   5,  21, 
+      5,   0,   0,   0,   2,  16, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  40,   0, 
+     86, 101, 114, 116, 101, 120, 
+     73, 110, 112, 117, 116,  84, 
+    121, 112, 101,   0, 242, 241, 
+     10,   0,   1,  18,   1,   0, 
+      0,   0,   3,  16,   0,   0, 
+     22,   0,  27,  21,  64,   0, 
       0,   0,   4,   0,   0,   0, 
-     66,   0,  60,  17,  16,   1, 
-      0,   0,   0,   1,  10,   0, 
-      1,   0,  76,  15, 244, 101, 
-     10,   0,   1,   0,  76,  15, 
-    244, 101,  77, 105,  99, 114, 
-    111, 115, 111, 102, 116,  32, 
-     40,  82,  41,  32,  72,  76, 
-     83,  76,  32,  83, 104,  97, 
-    100, 101, 114,  32,  67, 111, 
-    109, 112, 105, 108, 101, 114, 
-     32,  49,  48,  46,  49,   0, 
-      0,   0,  54,   0,  61,  17, 
-      1, 104, 108, 115, 108,  70, 
-    108,  97, 103, 115,   0,  48, 
-    120,  53,   0, 104, 108, 115, 
-    108,  84,  97, 114, 103, 101, 
-    116,   0, 118, 115,  95,  53, 
-     95,  49,   0, 104, 108, 115, 
-    108,  69, 110, 116, 114, 121, 
-      0, 109,  97, 105, 110,   0, 
-      0,   0,   0,   0,  42,   0, 
-     16,  17,   0,   0,   0,   0, 
-    152,   5,   0,   0,   0,   0, 
-      0,   0, 104,   3,   0,   0, 
-      0,   0,   0,   0, 104,   3, 
-      0,   0,   9,  16,   0,   0, 
-    176,   0,   0,   0,   1,   0, 
-    160, 109,  97, 105, 110,   0, 
-     46,   0,  62,  17,   3,  16, 
-      0,   0,   9,   0, 105, 110, 
-    112, 117, 116,   0,   0,   0, 
+     16,   0, 102, 108, 111,  97, 
+    116,  52,   0, 243, 242, 241, 
+     78,   0,   3,  18,  13,  21, 
+      3,   0,   5,  16,   0,   0, 
+      0,   0, 119, 111, 114, 108, 
+    100,  80, 111, 115,   0, 241, 
+     13,  21,   3,   0,   5,  16, 
+      0,   0,  16,   0, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+      0, 241,  13,  21,   3,   0, 
+      1,  16,   0,   0,  32,   0, 
+    116, 101, 120,   0, 242, 241, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,  40,   0, 110, 111, 
+    114, 109,  97, 108,   0, 243, 
+    242, 241,  38,   0,   5,  21, 
+      4,   0,   0,   0,   6,  16, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  52,   0, 
+     80, 105, 120, 101, 108,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,   0, 243, 242, 241, 
+     10,   0,  24,  21,   7,  16, 
+      0,   0,   1,   0,   1,   0, 
+     14,   0,   8,  16,   8,  16, 
+      0,   0,  23,   0,   1,   0, 
+      4,  16,   0,   0,  30,   0, 
+     28,  21,  64,   0,   0,   0, 
+      4,   0,   0,   0,   4,   0, 
+      0,   0,  16,   0,   0,   0, 
+      0,  64,   0, 102, 108, 111, 
+     97, 116,  52, 120,  52,   0, 
+     42,   0,   3,  18,  13,  21, 
+      3,   0,  10,  16,   0,   0, 
+      0,   0, 118, 105, 101, 119, 
+      0, 241,  13,  21,   3,   0, 
+     10,  16,   0,   0,  64,   0, 
+    112, 114, 111, 106, 101,  99, 
+    116, 105, 111, 110,   0, 243, 
+    242, 241,  34,   0,   5,  21, 
+      2,   0,   0,   0,  11,  16, 
+      0,   0,  11, 202,  49,   1, 
+     56,   0,   0,   0,   0,  16, 
+      0,   0,   0,  16,   0,   0, 
+      0,   0,   0,   0,  11,   0, 
+    255, 255,   4,   0,   0,   0, 
+    255, 255,   3,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   0,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   4,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   4,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   8,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   8,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  12,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  16,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  16,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  20,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  20,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  32,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  24,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  36,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  28,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  40,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  32,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  48,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  36,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  64,   0,   0,   0, 
-     58,   0,  62,  17,   8,  16, 
-      0,   0, 136,   0,  60, 109, 
-     97, 105, 110,  32, 114, 101, 
-    116, 117, 114, 110,  32, 118, 
-     97, 108, 117, 101,  62,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  40,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  48,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  44,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  52,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  48,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  56,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  32,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  32,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  36,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  36,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  16,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  16,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  20,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  20,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  24,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  24,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  28,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  28,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   0,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   4,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   4,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   8,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,   8,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  12,   0,   4,   0, 
-    176,   0,   0,   0,   1,   0, 
-    104,   3,  12,   0,   0,   0, 
-     46,   0,  62,  17,   7,  16, 
-      0,   0,   8,   0, 111, 117, 
-    116, 112, 117, 116,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  40,   0,   4,   0, 
-    156,   1,   0,   0,   1,   0, 
-    124,   2,   0,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  44,   0,   4,   0, 
-    156,   1,   0,   0,   1,   0, 
-    124,   2,   4,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  48,   0,   4,   0, 
-    156,   1,   0,   0,   1,   0, 
-    124,   2,   8,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  32,   0,   4,   0, 
-    216,   1,   0,   0,   1,   0, 
-     64,   2,  32,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  36,   0,   4,   0, 
-    216,   1,   0,   0,   1,   0, 
-     64,   2,  36,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-     32,   2,   0,   0,   1,   0, 
-    248,   1,  48,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-     76,   2,   0,   0,   1,   0, 
-    204,   1,  52,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-    120,   2,   0,   0,   1,   0, 
-    160,   1,  56,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  12,   0,   4,   0, 
-    164,   2,   0,   0,   1,   0, 
-    116,   1,  60,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  16,   0,   4,   0, 
-    200,   2,   0,   0,   1,   0, 
-    144,   0,  16,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  20,   0,   4,   0, 
-    236,   2,   0,   0,   1,   0, 
-    144,   0,  20,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  24,   0,   4,   0, 
-     16,   3,   0,   0,   1,   0, 
-    144,   0,  24,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  28,   0,   4,   0, 
-     52,   3,   0,   0,   1,   0, 
-    144,   0,  28,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  16,   0,   4,   0, 
-     88,   3,   0,   0,   1,   0, 
-    192,   0,  64,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  20,   0,   4,   0, 
-    124,   3,   0,   0,   1,   0, 
-    156,   0,  68,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  24,   0,   4,   0, 
-    160,   3,   0,   0,   1,   0, 
-    120,   0,  72,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  28,   0,   4,   0, 
-    196,   3,   0,   0,   1,   0, 
-     84,   0,  76,   0,   0,   0, 
-     46,   0,  62,  17,   5,  16, 
-      0,   0,   8,   0, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-    176,   1,   0,   0,   1,   0, 
-     24,   1,  16,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-    176,   1,   0,   0,   1,   0, 
-     60,   1,  20,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-    176,   1,   0,   0,   1,   0, 
-     96,   1,  24,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  12,   0,   4,   0, 
-    196,   1,   0,   0,   1,   0, 
-    112,   1,  28,   0,   0,   0, 
-      2,   0,   6,   0, 244,   0, 
-      0,   0,  24,   0,   0,   0, 
-      1,   0,   0,   0,  16,   1, 
-    246, 167,  61,  99, 243, 244, 
-     18,  82, 183, 159, 174,  72, 
-    213, 136, 161, 192,   0,   0, 
-    242,   0,   0,   0, 184,   2, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   1,   0,  24,   4, 
-      0,   0,   0,   0,   0,   0, 
-     56,   0,   0,   0, 172,   2, 
-      0,   0, 176,   0,   0,   0, 
-     65,   0,   0, 128, 176,   0, 
-      0,   0,  65,   0,   0,   0, 
-    208,   0,   0,   0,  65,   0, 
-      0, 128, 208,   0,   0,   0, 
-     65,   0,   0,   0, 248,   0, 
-      0,   0,  65,   0,   0, 128, 
-    248,   0,   0,   0,  65,   0, 
-      0,   0,  36,   1,   0,   0, 
-     65,   0,   0, 128,  36,   1, 
-      0,   0,  65,   0,   0,   0, 
-     80,   1,   0,   0,  65,   0, 
-      0, 128,  80,   1,   0,   0, 
-     65,   0,   0,   0, 108,   1, 
-      0,   0,  65,   0,   0, 128, 
-    108,   1,   0,   0,  65,   0, 
-      0,   0, 128,   1,   0,   0, 
-     65,   0,   0, 128, 128,   1, 
-      0,   0,  65,   0,   0,   0, 
-    156,   1,   0,   0,  68,   0, 
-      0, 128, 156,   1,   0,   0, 
-     68,   0,   0,   0, 176,   1, 
-      0,   0,  68,   0,   0, 128, 
-    176,   1,   0,   0,  68,   0, 
-      0,   0, 196,   1,   0,   0, 
-     70,   0,   0, 128, 196,   1, 
-      0,   0,  70,   0,   0,   0, 
-    216,   1,   0,   0,  73,   0, 
-      0, 128, 216,   1,   0,   0, 
-     73,   0,   0,   0, 248,   1, 
-      0,   0,  73,   0,   0, 128, 
-    248,   1,   0,   0,  73,   0, 
-      0,   0,  32,   2,   0,   0, 
-     73,   0,   0, 128,  32,   2, 
-      0,   0,  73,   0,   0,   0, 
-     76,   2,   0,   0,  73,   0, 
-      0, 128,  76,   2,   0,   0, 
-     73,   0,   0,   0, 120,   2, 
-      0,   0,  73,   0,   0, 128, 
-    120,   2,   0,   0,  73,   0, 
-      0,   0, 164,   2,   0,   0, 
-     74,   0,   0, 128, 164,   2, 
-      0,   0,  74,   0,   0,   0, 
-    200,   2,   0,   0,  74,   0, 
-      0, 128, 200,   2,   0,   0, 
-     74,   0,   0,   0, 236,   2, 
-      0,   0,  74,   0,   0, 128, 
-    236,   2,   0,   0,  74,   0, 
-      0,   0,  16,   3,   0,   0, 
-     74,   0,   0, 128,  16,   3, 
-      0,   0,  74,   0,   0,   0, 
-     52,   3,   0,   0,  75,   0, 
-      0, 128,  52,   3,   0,   0, 
-     75,   0,   0,   0,  88,   3, 
-      0,   0,  75,   0,   0, 128, 
-     88,   3,   0,   0,  75,   0, 
-      0,   0, 124,   3,   0,   0, 
-     75,   0,   0, 128, 124,   3, 
-      0,   0,  75,   0,   0,   0, 
-    160,   3,   0,   0,  75,   0, 
-      0, 128, 160,   3,   0,   0, 
-     75,   0,   0,   0, 196,   3, 
-      0,   0,  76,   0,   0, 128, 
-    196,   3,   0,   0,  76,   0, 
-      0,   0, 216,   3,   0,   0, 
-     76,   0,   0, 128, 216,   3, 
-      0,   0,  76,   0,   0,   0, 
-    236,   3,   0,   0,  76,   0, 
-      0, 128, 236,   3,   0,   0, 
-     76,   0,   0,   0,   0,   4, 
-      0,   0,  76,   0,   0, 128, 
-      0,   4,   0,   0,  76,   0, 
-      0,   0,  20,   4,   0,   0, 
-     76,   0,   0, 128,  20,   4, 
-      0,   0,  76,   0,   0,   0, 
-      2,   0,  94,   0,  56,   0, 
-     91,   0,   2,   0,  94,   0, 
-     28,   0,  92,   0,   2,   0, 
-     94,   0,  28,   0,  92,   0, 
-      2,   0,  94,   0,  28,   0, 
-     92,   0,   2,   0,  94,   0, 
-     18,   0,  93,   0,   2,   0, 
-     94,   0,  18,   0,  93,   0, 
-      2,   0,  94,   0,  18,   0, 
-     93,   0,   2,   0,  85,   0, 
-      9,   0,  84,   0,   2,   0, 
-     85,   0,   9,   0,  84,   0, 
-      2,   0,  24,   0,   2,   0, 
-     23,   0,   2,   0,  71,   0, 
-     34,   0,  69,   0,   2,   0, 
-     71,   0,  20,   0,  70,   0, 
-      2,   0,  71,   0,  20,   0, 
-     70,   0,   2,   0,  71,   0, 
-     20,   0,  70,   0,   2,   0, 
-     71,   0,  20,   0,  70,   0, 
-      2,   0,  53,   0,  20,   0, 
-     52,   0,   2,   0,  53,   0, 
-     20,   0,  52,   0,   2,   0, 
-     53,   0,  20,   0,  52,   0, 
-      2,   0,  53,   0,  20,   0, 
-     52,   0,   2,   0,  59,   0, 
-     20,   0,  58,   0,   2,   0, 
-     59,   0,  20,   0,  58,   0, 
-      2,   0,  59,   0,  20,   0, 
-     58,   0,   2,   0,  59,   0, 
-     20,   0,  58,   0,   2,   0, 
-     15,   0,   2,   0,  15,   0, 
-      2,   0,  15,   0,   2,   0, 
-     15,   0,   2,   0,  15,   0, 
-      2,   0,  15,   0,   2,   0, 
-     15,   0,   2,   0,  15,   0, 
-      2,   0,  15,   0,   2,   0, 
-     15,   0, 246,   0,   0,   0, 
-      4,   0,   0,   0,   0,   0, 
-      0,   0,  12,   0,   0,   0, 
-      0,   0,   0,   0,  20,   0, 
-      0,   0,  56,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2203,39 +2369,211 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    114,  97,  66, 117, 102, 102, 
-    101, 114,   0,  10,   0,  24, 
-     21,  12,  16,   0,   0,   1, 
-      0,   1,   0,  12,   0,  23, 
-     21,  13,  16,   0,   0,  36, 
-      2,   0,   0,   0,   0,  10, 
-      0,  24,  21,  14,  16,   0, 
-      0,   1,   0,   0,   2,  17, 
-      0,  22,  21,  10,  16,   0, 
-      0,  34,   0,   0,   0,   1, 
-      0,   0,   0,   0,   0,   0, 
-     26,   0,   3,  18,  13,  21, 
-      3,   0,  16,  16,   0,   0, 
-      0,   0, 107, 110, 111,  99, 
-    104, 101, 110,  77,  97, 116, 
-    114, 105, 120,   0,  33,   0, 
-      5,  21,   1,   0,   0,   0, 
-     17,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  32,  77,  97, 116, 114, 
-    105, 120,  66, 117, 102, 102, 
-    101, 114,   0,  10,   0,  24, 
-     21,  18,  16,   0,   0,   1, 
-      0,   1,   0,  12,   0,  23, 
-     21,  19,  16,   0,   0,  36, 
-      2, 208,  91,   0,   0,  10, 
-      0,  24,  21,  20,  16,   0, 
-      0,   1,   0,   0,   2,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  52,  41, 
+     59,  13,  10,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     86, 101, 114, 116, 101, 120, 
+     73, 110, 112, 117, 116,  84, 
+    121, 112, 101,  13,  10, 123, 
+     13,  10,   9, 102, 108, 111, 
+     97, 116,  51,  32, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     32,  58,  32,  80,  79,  83, 
+     73,  84,  73,  79,  78,  59, 
+     13,  10,   9, 102, 108, 111, 
+     97, 116,  50,  32, 116, 101, 
+    120,  32,  58,  32,  84,  69, 
+     88,  67,  79,  79,  82,  68, 
+     59,  13,  10,   9, 102, 108, 
+    111,  97, 116,  51,  32, 110, 
+    111, 114, 109,  97, 108,  32, 
+     58,  32,  78,  79,  82,  77, 
+     65,  76,  59,  13,  10,   9, 
+    117, 105, 110, 116,  32, 107, 
+    110, 111,  99, 104, 101, 110, 
+     32,  58,  32,  75,  78,  79, 
+     67,  72,  69,  78,  95,  73, 
+     68,  59,  13,  10,   9, 117, 
+    105, 110, 116,  32, 105, 100, 
+     32,  58,  32,  86,  69,  82, 
+     84,  69,  88,  95,  73,  68, 
+     59,  13,  10, 125,  59,  13, 
+     10,  13,  10, 115, 116, 114, 
+    117,  99, 116,  32,  80, 105, 
+    120, 101, 108,  73, 110, 112, 
+    117, 116,  84, 121, 112, 101, 
+     13,  10, 123,  13,  10,   9, 
+    102, 108, 111,  97, 116,  52, 
+     32, 119, 111, 114, 108, 100, 
+     80, 111, 115,  32,  58,  32, 
+     80,  79,  83,  73,  84,  73, 
+     79,  78,  59,  13,  10,   9, 
+    102, 108, 111,  97, 116,  52, 
+     32, 112, 111, 115, 105, 116, 
+    105, 111, 110,  32,  58,  32, 
+     83,  86,  95,  80,  79,  83, 
+     73,  84,  73,  79,  78,  59, 
+     13,  10,   9, 102, 108, 111, 
+     97, 116,  50,  32, 116, 101, 
+    120,  32,  58,  32,  84,  69, 
+     88,  67,  79,  79,  82,  68, 
+     59,  13,  10,   9, 102, 108, 
+    111,  97, 116,  51,  32, 110, 
+    111, 114, 109,  97, 108,  32, 
+     58,  32,  78,  79,  82,  77, 
+     65,  76,  59,  13,  10, 125, 
+     59,  13,  10,  13,  10,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 109,  97, 105, 110, 
+     40,  86, 101, 114, 116, 101, 
+    120,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,  32, 105, 
+    110, 112, 117, 116,  41,  13, 
+     10, 123,  13,  10,   9,  47, 
+     47, 114, 101, 116, 117, 114, 
+    110,  32, 105, 110, 112, 117, 
+    116,  59,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  13, 
+     10,   9,  80, 105, 120, 101, 
+    108,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,  32, 111, 
+    117, 116, 112, 117, 116,  59, 
+     13,  10,   9, 111, 117, 116, 
+    112, 117, 116,  46, 110, 111, 
+    114, 109,  97, 108,  32,  61, 
+     32, 110, 111, 114, 109,  97, 
+    108, 105, 122, 101,  40, 109, 
+    117, 108,  40, 105, 110, 112, 
+    117, 116,  46, 110, 111, 114, 
+    109,  97, 108,  44,  32,  40, 
+    102, 108, 111,  97, 116,  51, 
+    120,  51,  41,  83, 107, 101, 
+    108, 101, 116, 116,  46, 107, 
+    110, 111,  99, 104, 101, 110, 
+     77,  97, 116, 114, 105, 120, 
+     91, 105, 110, 112, 117, 116, 
+     46, 107, 110, 111,  99, 104, 
+    101, 110,  93,  41,  41,  59, 
+     13,  10,  13,  10,   9,  47, 
+     47,  32,  67, 104,  97, 110, 
+    103, 101,  32, 116, 104, 101, 
+     32, 112, 111, 115, 105, 116, 
+    105, 111, 110,  32, 118, 101, 
+     99, 116, 111, 114,  32, 116, 
+    111,  32,  98, 101,  32,  52, 
+     32, 117, 110, 105, 116, 115, 
+     32, 102, 111, 114,  32, 112, 
+    114, 111, 112, 101, 114,  32, 
+    109,  97, 116, 114, 105, 120, 
+     32,  99,  97, 108,  99, 117, 
+    108,  97, 116, 105, 111, 110, 
+    115,  46,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  52,  32, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+     61,  32, 102, 108, 111,  97, 
+    116,  52,  40, 105, 110, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    120,  44,  32, 105, 110, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    121,  44,  32, 105, 110, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    122,  44,  32,  49,  46, 102, 
+     41,  59,  13,  10,   9,  47, 
+     47,  32,  83, 116, 111, 114, 
+    101,  32, 116, 104, 101,  32, 
+    116, 101, 120, 116, 117, 114, 
+    101,  32,  99, 111, 111, 114, 
+    100, 105, 110,  97, 116, 101, 
+    115,  32, 102, 111, 114,  32, 
+    116, 104, 101,  32, 112, 105, 
+    120, 101, 108,  32, 115, 104, 
+     97, 100, 101, 114,  46,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  13, 
+     10,   9, 111, 117, 116, 112, 
+    117, 116,  46, 116, 101, 120, 
+     32,  61,  32, 105, 110, 112, 
+    117, 116,  46, 116, 101, 120, 
+     59,  13,  10,  13,  10,   9, 
+     47,  47,  32,  67,  97, 108, 
+     99, 117, 108,  97, 116, 101, 
+     32, 116, 104, 101,  32, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32, 111, 102,  32, 116, 
+    104, 101,  32, 118, 101, 114, 
+    116, 101, 120,  32,  97, 103, 
+     97, 105, 110, 115, 116,  32, 
+    116, 104, 101,  32, 119, 111, 
+    114, 108, 100,  44,  32, 118, 
+    105, 101, 119,  44,  32,  97, 
+    110, 100,  32, 112, 114, 111, 
+    106, 101,  99, 116, 105, 111, 
+    110,  32, 109,  97, 116, 114, 
+    105,  99, 101, 115,  46,  32, 
+     13,  10,   9, 111, 117, 116, 
+    112, 117, 116,  46, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+     32,  61,  32, 109, 117, 108, 
+     40, 112, 111, 115, 105, 116, 
+    105, 111, 110,  44,  32,  83, 
+    107, 101, 108, 101, 116, 116, 
+     46, 107, 110, 111,  99, 104, 
+    101, 110,  77,  97, 116, 114, 
+    105, 120,  91, 105, 110, 112, 
+    117, 116,  46, 107, 110, 111, 
+     99, 104, 101, 110,  93,  41, 
+     59,  13,  10,   9, 111, 117, 
+    116, 112, 117, 116,  46, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  61,  32, 109, 117, 
+    108,  40, 111, 117, 116, 112, 
+    117, 116,  46, 119, 111, 114, 
+    108, 100,  80, 111, 115,  44, 
+     32,  75,  97, 109, 101, 114, 
+     97,  46, 118, 105, 101, 119, 
+     41,  59,  13,  10,   9, 111, 
+    117, 116, 112, 117, 116,  46, 
+    112, 111, 115, 105, 116, 105, 
+    111, 110,  32,  61,  32, 109, 
+    117, 108,  40, 111, 117, 116, 
+    112, 117, 116,  46, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     44,  32,  75,  97, 109, 101, 
+    114,  97,  46, 112, 114, 111, 
+    106, 101,  99, 116, 105, 111, 
+    110,  41,  59,  13,  10,   9, 
+    114, 101, 116, 117, 114, 110, 
+     32, 111, 117, 116, 112, 117, 
+    116,  59,  13,  10, 125,   0, 
+      7,   0,   0,   0, 170,   0, 
+      0,   0,  85,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,  86,   0, 
+      0,   0,   4,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2288,101 +2626,17 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  11, 202,  49,   1, 
-     56,   0,   0,   0,   0,  16, 
-      0,   0,  22,  16,   0,   0, 
-    111,   2,   0,   0,  11,   0, 
-    255, 255,   4,   0,   0,   0, 
-    255, 255,   3,   0,   0,   0, 
-      0,   0,  88,   0,   0,   0, 
-     88,   0,   0,   0,   8,   0, 
-      0,   0,  96,   0,   0,   0, 
-      0,   0,   0,   0,  19,   0, 
-     27,  21,  64,   0,   0,   0, 
-      3,   0,   0,   0,  12,   0, 
-    102, 108, 111,  97, 116,  51, 
-      0,  19,   0,  27,  21,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   8,   0, 102, 108, 111, 
-     97, 116,  50,   0,  94,   0, 
-      3,  18,  13,  21,   3,   0, 
-      0,  16,   0,   0,   0,   0, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,   0, 241,  13,  21, 
-      3,   0,   1,  16,   0,   0, 
-     12,   0, 116, 101, 120,   0, 
-    242, 241,  13,  21,   3,   0, 
-      0,  16,   0,   0,  20,   0, 
-    110, 111, 114, 109,  97, 108, 
-      0, 243, 242, 241,  13,  21, 
-      3,   0, 117,   0,   0,   0, 
-     32,   0, 107, 110, 111,  99, 
-    104, 101, 110,   0, 242, 241, 
-     13,  21,   3,   0, 117,   0, 
-      0,   0,  36,   0, 105, 100, 
-      0, 243, 242, 241,  36,   0, 
-      5,  21,   5,   0,   0,   0, 
-      2,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,  86, 101, 114, 116, 
-    101, 120,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,   0, 
-     10,   0,   1,  18,   1,   0, 
-      0,   0,   3,  16,   0,   0, 
-     19,   0,  27,  21,  64,   0, 
-      0,   0,   4,   0,   0,   0, 
-     16,   0, 102, 108, 111,  97, 
-    116,  52,   0,  78,   0,   3, 
-     18,  13,  21,   3,   0,   5, 
-     16,   0,   0,   0,   0, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,   0, 241,  13,  21,   3, 
-      0,   5,  16,   0,   0,  16, 
-      0, 112, 111, 115, 105, 116, 
-    105, 111, 110,   0, 241,  13, 
-     21,   3,   0,   1,  16,   0, 
-      0,  32,   0, 116, 101, 120, 
-      0, 242, 241,  13,  21,   3, 
-      0,   0,  16,   0,   0,  40, 
-      0, 110, 111, 114, 109,  97, 
-    108,   0, 243, 242, 241,  35, 
-      0,   5,  21,   4,   0,   0, 
-      0,   6,  16,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  52,   0,  80, 105, 120, 
-    101, 108,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,   0, 
-     10,   0,  24,  21,   7,  16, 
-      0,   0,   1,   0,   1,   0, 
-     14,   0,   8,  16,   8,  16, 
-      0,   0,  23,   0,   1,   0, 
-      4,  16,   0,   0,  30,   0, 
-     28,  21,  64,   0,   0,   0, 
-      4,   0,   0,   0,   4,   0, 
-      0,   0,  16,   0,   0,   0, 
-      0,  64,   0, 102, 108, 111, 
-     97, 116,  52, 120,  52,   0, 
-     42,   0,   3,  18,  13,  21, 
-      3,   0,  10,  16,   0,   0, 
-      0,   0, 118, 105, 101, 119, 
-      0, 241,  13,  21,   3,   0, 
-     10,  16,   0,   0,  64,   0, 
-    112, 114, 111, 106, 101,  99, 
-    116, 105, 111, 110,   0, 243, 
-    242, 241,  33,   0,   5,  21, 
-      2,   0,   0,   0,  11,  16, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 128,   0, 
-     75,  97, 109, 101,  11, 202, 
-     49,   1,  56,   0,   0,   0, 
-      0,  16,   0,   0,   0,  16, 
       0,   0,   0,   0,   0,   0, 
-     13,   0, 255, 255,   4,   0, 
-      0,   0, 255, 255,   3,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  68,  51, 
+     68,  83,  72,  68,  82,   0, 
+     24,   4,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  32,   0, 
+      0,  96,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2459,207 +2713,15 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     52,  41,  59,  13,  10,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  86, 101, 114, 116, 
-    101, 120,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,  13, 
-     10, 123,  13,  10,   9, 102, 
-    108, 111,  97, 116,  51,  32, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  32,  58,  32,  80, 
-     79,  83,  73,  84,  73,  79, 
-     78,  59,  13,  10,   9, 102, 
-    108, 111,  97, 116,  50,  32, 
-    116, 101, 120,  32,  58,  32, 
-     84,  69,  88,  67,  79,  79, 
-     82,  68,  59,  13,  10,   9, 
-    102, 108, 111,  97, 116,  51, 
-     32, 110, 111, 114, 109,  97, 
-    108,  32,  58,  32,  78,  79, 
-     82,  77,  65,  76,  59,  13, 
-     10,   9, 117, 105, 110, 116, 
-     32, 107, 110, 111,  99, 104, 
-    101, 110,  32,  58,  32,  75, 
-     78,  79,  67,  72,  69,  78, 
-     95,  73,  68,  59,  13,  10, 
-      9, 117, 105, 110, 116,  32, 
-    105, 100,  32,  58,  32,  86, 
-     69,  82,  84,  69,  88,  95, 
-     73,  68,  59,  13,  10, 125, 
-     59,  13,  10,  13,  10, 115, 
-    116, 114, 117,  99, 116,  32, 
-     80, 105, 120, 101, 108,  73, 
-    110, 112, 117, 116,  84, 121, 
-    112, 101,  13,  10, 123,  13, 
-     10,   9, 102, 108, 111,  97, 
-    116,  52,  32, 119, 111, 114, 
-    108, 100,  80, 111, 115,  32, 
-     58,  32,  80,  79,  83,  73, 
-     84,  73,  79,  78,  59,  13, 
-     10,   9, 102, 108, 111,  97, 
-    116,  52,  32, 112, 111, 115, 
-    105, 116, 105, 111, 110,  32, 
-     58,  32,  83,  86,  95,  80, 
-     79,  83,  73,  84,  73,  79, 
-     78,  59,  13,  10,   9, 102, 
-    108, 111,  97, 116,  50,  32, 
-    116, 101, 120,  32,  58,  32, 
-     84,  69,  88,  67,  79,  79, 
-     82,  68,  59,  13,  10,   9, 
-    102, 108, 111,  97, 116,  51, 
-     32, 110, 111, 114, 109,  97, 
-    108,  32,  58,  32,  78,  79, 
-     82,  77,  65,  76,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 109,  97, 
-    105, 110,  40,  86, 101, 114, 
-    116, 101, 120,  73, 110, 112, 
-    117, 116,  84, 121, 112, 101, 
-     32, 105, 110, 112, 117, 116, 
-     41,  13,  10, 123,  13,  10, 
-      9,  47,  47, 114, 101, 116, 
-    117, 114, 110,  32, 105, 110, 
-    112, 117, 116,  59,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  13,  10,   9,  80, 105, 
-    120, 101, 108,  73, 110, 112, 
-    117, 116,  84, 121, 112, 101, 
-     32, 111, 117, 116, 112, 117, 
-    116,  59,  13,  10,   9, 111, 
-    117, 116, 112, 117, 116,  46, 
-    110, 111, 114, 109,  97, 108, 
-     32,  61,  32, 110, 111, 114, 
-    109,  97, 108, 105, 122, 101, 
-     40, 109, 117, 108,  40, 105, 
-    110, 112, 117, 116,  46, 110, 
-    111, 114, 109,  97, 108,  44, 
-     32,  40, 102, 108, 111,  97, 
-    116,  51, 120,  51,  41,  83, 
-    107, 101, 108, 101, 116, 116, 
-     46, 107, 110, 111,  99, 104, 
-    101, 110,  77,  97, 116, 114, 
-    105, 120,  91, 105, 110, 112, 
-    117, 116,  46, 107, 110, 111, 
-     99, 104, 101, 110,  93,  41, 
-     41,  59,  13,  10,  13,  10, 
-      9,  47,  47,  32,  67, 104, 
-     97, 110, 103, 101,  32, 116, 
-    104, 101,  32, 112, 111, 115, 
-    105, 116, 105, 111, 110,  32, 
-    118, 101,  99, 116, 111, 114, 
-     32, 116, 111,  32,  98, 101, 
-     32,  52,  32, 117, 110, 105, 
-    116, 115,  32, 102, 111, 114, 
-     32, 112, 114, 111, 112, 101, 
-    114,  32, 109,  97, 116, 114, 
-    105, 120,  32,  99,  97, 108, 
-     99, 117, 108,  97, 116, 105, 
-    111, 110, 115,  46,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  61,  32, 102, 108, 
-    111,  97, 116,  52,  40, 105, 
-    110, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 120,  44,  32, 105, 
-    110, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 121,  44,  32, 105, 
-    110, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 122,  44,  32,  49, 
-     46, 102,  41,  59,  13,  10, 
-      9,  47,  47,  32,  83, 116, 
-    111, 114, 101,  32, 116, 104, 
-    101,  32, 116, 101, 120, 116, 
-    117, 114, 101,  32,  99, 111, 
-    111, 114, 100, 105, 110,  97, 
-    116, 101, 115,  32, 102, 111, 
-    114,  32, 116, 104, 101,  32, 
-    112, 105, 120, 101, 108,  32, 
-    115, 104,  97, 100, 101, 114, 
-     46,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  13,  10,   9, 111, 117, 
-    116, 112, 117, 116,  46, 116, 
-    101, 120,  32,  61,  32, 105, 
-    110, 112, 117, 116,  46, 116, 
-    101, 120,  59,  13,  10,  13, 
-     10,   9,  47,  47,  32,  67, 
-     97, 108,  99, 117, 108,  97, 
-    116, 101,  32, 116, 104, 101, 
-     32, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32, 111, 102, 
-     32, 116, 104, 101,  32, 118, 
-    101, 114, 116, 101, 120,  32, 
-     97, 103,  97, 105, 110, 115, 
-    116,  32, 116, 104, 101,  32, 
-    119, 111, 114, 108, 100,  44, 
-     32, 118, 105, 101, 119,  44, 
-     32,  97, 110, 100,  32, 112, 
-    114, 111, 106, 101,  99, 116, 
-    105, 111, 110,  32, 109,  97, 
-    116, 114, 105,  99, 101, 115, 
-     46,  32,  13,  10,   9, 111, 
-    117, 116, 112, 117, 116,  46, 
-    119, 111, 114, 108, 100,  80, 
-    111, 115,  32,  61,  32, 109, 
-    117, 108,  40, 112, 111, 115, 
-    105, 116, 105, 111, 110,  44, 
-     32,  83, 107, 101, 108, 101, 
-    116, 116,  46, 107, 110, 111, 
-     99, 104, 101, 110,  77,  97, 
-    116, 114, 105, 120,  91, 105, 
-    110, 112, 117, 116,  46, 107, 
-    110, 111,  99, 104, 101, 110, 
-     93,  41,  59,  13,  10,   9, 
-    111, 117, 116, 112, 117, 116, 
-     46, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32,  61,  32, 
-    109, 117, 108,  40, 111, 117, 
-    116, 112, 117, 116,  46, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,  44,  32,  75,  97, 109, 
-    101, 114,  97,  46, 118, 105, 
-    101, 119,  41,  59,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  61, 
-     32, 109, 117, 108,  40, 111, 
-    117, 116, 112, 117, 116,  46, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  44,  32,  75,  97, 
-    109, 101, 114,  97,  46, 112, 
-    114, 111, 106, 101,  99, 116, 
-    105, 111, 110,  41,  59,  13, 
-     10,   9, 114, 101, 116, 117, 
-    114, 110,  32, 111, 117, 116, 
-    112, 117, 116,  59,  13,  10, 
-    125,   0,   7,   0,   0,   0, 
-    170,   0,   0,   0,  85,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,  26,   9, 
+     47, 241,  24,   0,   0,   0, 
+     16,   2,   0,   0,   1,   0, 
       0,   0,   1,   0,   0,   0, 
-     86,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
+     21,   0,   0,   0,   1,   0, 
+      0,   0,  57,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2671,6 +2733,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+     32,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2706,6 +2769,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,  16,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2715,13 +2779,10 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     68,  51,  68,  83,  72,  68, 
-     82,   0,  24,   4,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  96,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2744,8 +2805,11 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,  32,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,  12,   0,   0,   0, 
+     24,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2800,13 +2864,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-     26,   9,  47, 241,  24,   0, 
-      0,   0,  16,   2,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  21,   0,   0,   0, 
-      1,   0,   0,   0,  57,   0, 
-      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2818,7 +2875,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2829,10 +2885,22 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  18,   0, 
+     37,  17,   0,   0,   0,   0, 
+    128,   0,   0,   0,   1,   0, 
+    109,  97, 105, 110,   0,   0, 
+     34,   0, 100,  17,  15,  16, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      8,   0,  75,  97, 109, 101, 
+    114,  97,   0,   0,   0,   0, 
+     34,   0, 100,  17,  21,  16, 
+      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      8,   0,  83, 107, 101, 108, 
+    101, 116, 116,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2854,7 +2922,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  16, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2890,11 +2957,8 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  12,   0, 
-      0,   0,  24,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2907,9 +2971,12 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,  26,   9,  47, 241, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2971,21 +3038,9 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     18,   0,  37,  17,   0,   0, 
-      0,   0, 128,   0,   0,   0, 
-      1,   0, 109,  97, 105, 110, 
-      0,   0,  34,   0, 100,  17, 
-     15,  16,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   8,   0,  75,  97, 
-    109, 101, 114,  97,   0,   0, 
-      0,   0,  34,   0, 100,  17, 
-     21,  16,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   8,   0,  83, 107, 
-    101, 108, 101, 116, 116,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3001,14 +3056,67 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+    119,   9,  49,   1,   1,   0, 
+      0,   0,  13,   0,  20, 142, 
+     14,   0,  20, 107,  15,   0, 
+      1,   0,  76,   0,   0,   0, 
+     32,   0,   0,   0,  44,   0, 
+      0,   0,  96,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,   0,   0, 
+     25,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
+     24,   4,   0,   0,  32,   0, 
+      0,  96,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   2,   0,   9,   0, 
+    156,   5,   0,   0,   0,   0, 
+      0,   0, 236,   2,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 109,  97, 
+    105, 110,   0, 110, 111, 110, 
+    101,   0,   0,   0,  45, 186, 
+     46, 241,   1,   0,   0,   0, 
+      0,   0,   0,   0,  24,   4, 
+      0,   0,  32,   0,   0,  96, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      2,   0,   2,   0,   7,   0, 
+      0,   0,   0,   0,   1,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0,  24,   4,   0,   0, 
+      8,   2,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   1,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
+      0,   0,  67,  58,  92,  85, 
+    115, 101, 114, 115,  92, 107, 
+    111, 108, 106,  97,  92,  68, 
+    101, 115, 107, 116, 111, 112, 
+     92,  75, 111, 108, 106,  97, 
+     45,  83, 116, 114, 111, 104, 
+    109,  45,  71,  97, 109, 101, 
+    115,  92,  65, 108, 108, 103, 
+    101, 109, 101, 105, 110,  92, 
+     70, 114,  97, 109, 101, 119, 
+    111, 114, 107,  92,  68,  88, 
+     49,  50,  86, 101, 114, 116, 
+    101, 120,  83, 104,  97, 100, 
+    101, 114,  46, 104, 108, 115, 
+    108,   0, 254, 239, 254, 239, 
+      1,   0,   0,   0,   1,   0, 
+      0,   0,   0,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0, 255, 255, 255, 
+    255, 255, 255, 255, 255, 255, 
+    255,  12,   0, 255, 255, 255, 
+    255, 255, 255, 255, 255, 255, 
+    255,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3033,7 +3141,44 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 148,  46, 
+     49,   1,  77, 224, 173, 104, 
+      1,   0,   0,   0, 176,   6, 
+    156, 218, 212, 106,  53,  66, 
+    145, 172, 152,  28,  27, 101, 
+    150, 163, 129,   0,   0,   0, 
+     47,  76, 105, 110, 107,  73, 
+    110, 102, 111,   0,  47, 110, 
+     97, 109, 101, 115,   0,  47, 
+    115, 114,  99,  47, 104, 101, 
+     97, 100, 101, 114,  98, 108, 
+    111,  99, 107,   0,  47, 115, 
+    114,  99,  47, 102, 105, 108, 
+    101, 115,  47,  99,  58,  92, 
+    117, 115, 101, 114, 115,  92, 
+    107, 111, 108, 106,  97,  92, 
+    100, 101, 115, 107, 116, 111, 
+    112,  92, 107, 111, 108, 106, 
+     97,  45, 115, 116, 114, 111, 
+    104, 109,  45, 103,  97, 109, 
+    101, 115,  92,  97, 108, 108, 
+    103, 101, 109, 101, 105, 110, 
+     92, 102, 114,  97, 109, 101, 
+    119, 111, 114, 107,  92, 100, 
+    120,  49,  50, 118, 101, 114, 
+    116, 101, 120, 115, 104,  97, 
+    100, 101, 114,  46, 104, 108, 
+    115, 108,   0,   4,   0,   0, 
+      0,   6,   0,   0,   0,   1, 
+      0,   0,   0,  58,   0,   0, 
+      0,   0,   0,   0,   0,  17, 
+      0,   0,   0,   7,   0,   0, 
+      0,  10,   0,   0,   0,   6, 
       0,   0,   0,   0,   0,   0, 
+      0,   5,   0,   0,   0,  34, 
+      0,   0,   0,   8,   0,   0, 
+      0,   0,   0,   0,   0, 220, 
+     81,  51,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3056,13 +3201,10 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,  26,   9, 
-     47, 241,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3085,6 +3227,35 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+     16,   0,   0,   0,  32,   0, 
+      0,   0, 221,   0,   0,   0, 
+    188,   2,   0,   0, 103,   1, 
+      0,   0,  56,   0,   0,   0, 
+      0,   0,   0,   0, 178,   8, 
+      0,   0, 128,   0,   0,   0, 
+    215,   7,   0,   0, 152,   8, 
+      0,   0,  96,   0,   0,   0, 
+      0,   0,   0,   0,  40,   0, 
+      0,   0,  56,   2,   0,   0, 
+     44,   0,   0,   0,  92,   0, 
+      0,   0,   3,   0,   0,   0, 
+     31,   0,   0,   0,  20,   0, 
+      0,   0,  19,   0,   0,   0, 
+     30,   0,   0,   0,  21,   0, 
+      0,   0,  12,   0,   0,   0, 
+      6,   0,   0,   0,  22,   0, 
+      0,   0,  23,   0,   0,   0, 
+     24,   0,   0,   0,  13,   0, 
+      0,   0,   8,   0,   0,   0, 
+      9,   0,   0,   0,  10,   0, 
+      0,   0,  11,   0,   0,   0, 
+     14,   0,   0,   0,  15,   0, 
+      0,   0,  16,   0,   0,   0, 
+     17,   0,   0,   0,  18,   0, 
+      0,   0,   7,   0,   0,   0, 
+     25,   0,   0,   0,  26,   0, 
+      0,   0,  27,   0,   0,   0, 
+     29,   0,   0,   0,  28,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3141,145 +3312,7 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255, 119,   9,  49,   1, 
-      1,   0,   0,   0,  15,   0, 
-     38, 142,  16,   0, 116, 129, 
-     17,   0, 100,   0,  76,   0, 
       0,   0,  32,   0,   0,   0, 
-     44,   0,   0,   0,  96,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  24,   0, 
-      0,   0,  25,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  24,   4,   0,   0, 
-     32,   0,   0,  96,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
-     10,   0, 156,   5,   0,   0, 
-      0,   0,   0,   0, 236,   2, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    109,  97, 105, 110,   0, 110, 
-    111, 110, 101,   0,   0,   0, 
-     45, 186,  46, 241,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-     24,   4,   0,   0,  32,   0, 
-      0,  96,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   2,   0, 
-      7,   0,   0,   0,   0,   0, 
-      1,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0,  24,   4, 
-      0,   0,   8,   2,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   0,   0,   0,   0, 
-    255, 255, 255, 255,   1,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,  67,  58, 
-     92,  85, 115, 101, 114, 115, 
-     92, 107, 111, 108, 106,  97, 
-     92,  68, 101, 115, 107, 116, 
-    111, 112,  92,  75, 111, 108, 
-    106,  97,  45,  83, 116, 114, 
-    111, 104, 109,  45,  71,  97, 
-    109, 101, 115,  92,  65, 108, 
-    108, 103, 101, 109, 101, 105, 
-    110,  92,  70, 114,  97, 109, 
-    101, 119, 111, 114, 107,  92, 
-     68,  88,  49,  50,  86, 101, 
-    114, 116, 101, 120,  83, 104, 
-     97, 100, 101, 114,  46, 104, 
-    108, 115, 108,   0, 254, 239, 
-    254, 239,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   1, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255,  14,   0, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1,   6, 118, 
-     88, 104,   1,   0,   0,   0, 
-     99, 131, 128, 156,  91, 251, 
-     24,  64, 189, 242,  78, 185, 
-    252, 184, 237,  55, 156,   0, 
-      0,   0,  47,  76, 105, 110, 
-    107,  73, 110, 102, 111,   0, 
-     47,  84,  77,  67,  97,  99, 
-    104, 101,   0,  47, 110,  97, 
-    109, 101, 115,   0,  47, 115, 
-    114,  99,  47, 104, 101,  97, 
-    100, 101, 114,  98, 108, 111, 
-     99, 107,   0,  47, 115, 114, 
-     99,  47, 102, 105, 108, 101, 
-    115,  47,  99,  58,  92, 117, 
-    115, 101, 114, 115,  92, 107, 
-    111, 108, 106,  97,  92, 100, 
-    101, 115, 107, 116, 111, 112, 
-     92, 107, 111, 108, 106,  97, 
-     45, 115, 116, 114, 111, 104, 
-    109,  45, 103,  97, 109, 101, 
-    115,  92,  97, 108, 108, 103, 
-    101, 109, 101, 105, 110,  92, 
-    102, 114,  97, 109, 101, 119, 
-    111, 114, 107,  92, 100, 120, 
-     49,  50, 118, 101, 114, 116, 
-    101, 120, 115, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0,  47,  85,  68,  84, 
-     83,  82,  67,  76,  73,  78, 
-     69,  85,  78,  68,  79,  78, 
-     69,   0,   6,   0,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   0,  63,   0,   0,   0, 
-      0,   0,   0,   0, 138,   0, 
-      0,   0,  12,   0,   0,   0, 
-     26,   0,   0,   0,   8,   0, 
-      0,   0,  43,   0,   0,   0, 
-      9,   0,   0,   0,   0,   0, 
-      0,   0,   5,   0,   0,   0, 
-     10,   0,   0,   0,   6,   0, 
-      0,   0,  19,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0, 220,  81,  51,   1, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3312,38 +3345,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  18,   0,   0,   0, 
-     40,   0,   0,   0,   8,   1, 
-      0,   0, 167,   2,   0,   0, 
-    105,   1,   0,   0,  56,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 178,   8, 
-      0,   0, 128,   0,   0,   0, 
-    215,   7,   0,   0, 152,   8, 
-      0,   0,  96,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  40,   0,   0,   0, 
-     56,   2,   0,   0,  44,   0, 
-      0,   0,  92,   0,   0,   0, 
-      7,   0,   0,   0,  32,   0, 
-      0,   0,  21,   0,   0,   0, 
-     20,   0,   0,   0,  31,   0, 
-      0,   0,  22,   0,   0,   0, 
-     13,   0,   0,   0,   3,   0, 
-      0,   0,  23,   0,   0,   0, 
-     24,   0,   0,   0,  25,   0, 
-      0,   0,  14,   0,   0,   0, 
-      9,   0,   0,   0,  10,   0, 
-      0,   0,  11,   0,   0,   0, 
-     12,   0,   0,   0,  15,   0, 
-      0,   0,  16,   0,   0,   0, 
-     17,   0,   0,   0,  18,   0, 
-      0,   0,  19,   0,   0,   0, 
-      4,   0,   0,   0,  26,   0, 
-      0,   0,  27,   0,   0,   0, 
-     28,   0,   0,   0,  30,   0, 
-      0,   0,  29,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3397,7 +3398,6 @@ const BYTE DX12VertexShaderBytes[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  33,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 

Framework Tests/Assembly.cpp

@@ -0,0 +1,206 @@
+#include "pch.h"
+
+#include "Assembly.h"
+#include "CppUnitTest.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+
+namespace FrameworkTests
+{
+    TEST_CLASS (AssemblyTests)
+    {
+    public:
+        TEST_METHOD (Add8Test)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::MOV,
+                    {new Framework::Assembly::GPRegisterArgument(
+                         Framework::Assembly::RAX, Framework::Assembly::LOWER8),
+                        new Framework::Assembly::GPRegisterArgument(
+                            Framework::Assembly::RDX,
+                            Framework::Assembly::LOWER8)}));
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::ADD,
+                    {new Framework::Assembly::GPRegisterArgument(
+                         Framework::Assembly::RAX, Framework::Assembly::LOWER8),
+                        new Framework::Assembly::GPRegisterArgument(
+                            Framework::Assembly::RCX,
+                            Framework::Assembly::LOWER8)}));
+            char (*add)(char a, char b)
+                = (char (*)(char, char))codeBlock.compile();
+            char result = add(22, 15);
+            char result2 = add(5, 6);
+            Assert::AreEqual((char)37, result);
+            Assert::AreEqual((char)11, result2);
+        }
+
+        TEST_METHOD (Add16Test)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(new Framework::Assembly::Instruction(
+                Framework::Assembly::MOV,
+                {new Framework::Assembly::GPRegisterArgument(
+                     Framework::Assembly::RAX, Framework::Assembly::LOWER16),
+                    new Framework::Assembly::GPRegisterArgument(
+                        Framework::Assembly::RDX,
+                        Framework::Assembly::LOWER16)}));
+            codeBlock.addInstruction(new Framework::Assembly::Instruction(
+                Framework::Assembly::ADD,
+                {new Framework::Assembly::GPRegisterArgument(
+                     Framework::Assembly::RAX, Framework::Assembly::LOWER16),
+                    new Framework::Assembly::GPRegisterArgument(
+                        Framework::Assembly::RCX,
+                        Framework::Assembly::LOWER16)}));
+            short (*add)(short a, short b)
+                = (short (*)(short, short))codeBlock.compile();
+            short result = add(22, 15);
+            short result2 = add(5, 6);
+            Assert::AreEqual((short)37, result);
+            Assert::AreEqual((short)11, result2);
+        }
+
+        TEST_METHOD (Add32Test)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(new Framework::Assembly::Instruction(
+                Framework::Assembly::MOV,
+                {new Framework::Assembly::GPRegisterArgument(
+                     Framework::Assembly::RAX, Framework::Assembly::LOWER32),
+                    new Framework::Assembly::GPRegisterArgument(
+                        Framework::Assembly::RDX,
+                        Framework::Assembly::LOWER32)}));
+            codeBlock.addInstruction(new Framework::Assembly::Instruction(
+                Framework::Assembly::ADD,
+                {new Framework::Assembly::GPRegisterArgument(
+                     Framework::Assembly::RAX, Framework::Assembly::LOWER32),
+                    new Framework::Assembly::GPRegisterArgument(
+                        Framework::Assembly::RCX,
+                        Framework::Assembly::LOWER32)}));
+            int (*add)(int a, int b) = (int (*)(int, int))codeBlock.compile();
+            int result = add(22, 15);
+            int result2 = add(5, 6);
+            Assert::AreEqual((int)37, result);
+            Assert::AreEqual((int)11, result2);
+        }
+
+        TEST_METHOD (Add64Test)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::MOV,
+                    {new Framework::Assembly::GPRegisterArgument(
+                         Framework::Assembly::RAX),
+                        new Framework::Assembly::GPRegisterArgument(
+                            Framework::Assembly::RDX)}));
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::ADD,
+                    {new Framework::Assembly::GPRegisterArgument(
+                         Framework::Assembly::RAX),
+                        new Framework::Assembly::GPRegisterArgument(
+                            Framework::Assembly::RCX)}));
+            __int64 (*add)(__int64 a, __int64 b)
+                = (__int64 (*)(__int64, __int64))codeBlock.compile();
+            __int64 result = add(22, 15);
+            __int64 result2 = add(5, 6);
+            Assert::AreEqual((__int64)37, result);
+            Assert::AreEqual((__int64)11, result2);
+        }
+
+        TEST_METHOD (AddFloatTest)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::ADDSS,
+                    {new Framework::Assembly::FPRegisterArgument(
+                         Framework::Assembly::MM0,
+                         Framework::Assembly::FPRegisterPart::X),
+                        new Framework::Assembly::FPRegisterArgument(
+                            Framework::Assembly::MM1,
+                            Framework::Assembly::FPRegisterPart::X)}));
+            float (*add)(float a, float b)
+                = (float (*)(float, float))codeBlock.compile();
+            float result = add(4.24f, 8.54f);
+            float result2 = add(0.3f, 7.6f);
+            Assert::AreEqual((float)(4.24f + 8.54f), result);
+            Assert::AreEqual((float)(0.3f + 7.6f), result2);
+        }
+
+        TEST_METHOD (AddDoubleTest)
+        {
+            Framework::Assembly::AssemblyBlock codeBlock;
+            codeBlock.addInstruction(
+                new Framework::Assembly::Instruction(Framework::Assembly::ADDSD,
+                    {new Framework::Assembly::FPRegisterArgument(
+                         Framework::Assembly::MM0,
+                         Framework::Assembly::FPRegisterPart::X),
+                        new Framework::Assembly::FPRegisterArgument(
+                            Framework::Assembly::MM1,
+                            Framework::Assembly::FPRegisterPart::X)}));
+            double (*add)(double a, double b)
+                = (double (*)(double, double))codeBlock.compile();
+            double result = add(4.24, 8.54);
+            double result2 = add(0.3, 7.6);
+            Assert::AreEqual(4.24 + 8.54, result);
+            Assert::AreEqual(0.3 + 7.6, result2);
+        }
+
+        TEST_METHOD (returnRefTest)
+        {
+            char cRef = 1;
+            short sRef = 2;
+            int iRef = 3;
+            __int64 lRef = 4;
+            float fRef = 5.0f;
+            double dRef = 6.0;
+            Framework::Assembly::AssemblyBlock ccodeBlock;
+            ccodeBlock.addLoadValue(&cRef, Framework::Assembly::RAX);
+            char (*getc)() = (char (*)())ccodeBlock.compile();
+            char cresult = getc();
+            Assert::AreEqual((char)1, cresult);
+            cRef = 11;
+            cresult = getc();
+            Assert::AreEqual((char)11, cresult);
+            Framework::Assembly::AssemblyBlock scodeBlock;
+            scodeBlock.addLoadValue(&sRef, Framework::Assembly::RAX);
+            short (*gets)() = (short (*)())scodeBlock.compile();
+            short sresult = gets();
+            Assert::AreEqual((short)2, sresult);
+            sRef = 22;
+            sresult = gets();
+            Assert::AreEqual((short)22, sresult);
+            Framework::Assembly::AssemblyBlock icodeBlock;
+            icodeBlock.addLoadValue(&iRef, Framework::Assembly::RAX);
+            int (*geti)() = (int (*)())icodeBlock.compile();
+            int iresult = geti();
+            Assert::AreEqual((int)3, iresult);
+            iRef = 33;
+            iresult = geti();
+            Assert::AreEqual((int)33, iresult);
+            Framework::Assembly::AssemblyBlock lcodeBlock;
+            lcodeBlock.addLoadValue(&lRef, Framework::Assembly::RAX);
+            __int64 (*getl)() = (__int64 (*)())lcodeBlock.compile();
+            __int64 lresult = getl();
+            Assert::AreEqual((__int64)4, lresult);
+            lRef = 44;
+            lresult = getl();
+            Assert::AreEqual((__int64)44, lresult);
+            Framework::Assembly::AssemblyBlock fcodeBlock;
+            fcodeBlock.addLoadValue(&fRef, Framework::Assembly::MM0);
+            float (*getf)() = (float (*)())fcodeBlock.compile();
+            float fresult = getf();
+            Assert::AreEqual((float)5.0f, fresult);
+            fRef = 55.0f;
+            fresult = getf();
+            Assert::AreEqual((float)55.0f, fresult);
+            Framework::Assembly::AssemblyBlock dcodeBlock;
+            dcodeBlock.addLoadValue(&dRef, Framework::Assembly::MM0);
+            double (*getd)() = (double (*)())dcodeBlock.compile();
+            double dresult = getd();
+            Assert::AreEqual((double)6.0, dresult);
+            dRef = 66.0;
+            dresult = getd();
+            Assert::AreEqual((double)66.0, dresult);
+        }
+    };
+} // namespace FrameworkTests

Framework Tests/Framework Tests.vcxproj

@@ -90,6 +90,8 @@
     <LinkIncremental>false</LinkIncremental>
     <SourcePath>C:\Users\kolja\Desktop\Kolja-Strohm-Games\Allgemein\Framework\;$(SourcePath)</SourcePath>
     <IncludePath>C:\Users\kolja\Desktop\Kolja-Strohm-Games\Allgemein\Framework;$(IncludePath)</IncludePath>
+    <ExternalIncludePath>..;$(ExternalIncludePath)</ExternalIncludePath>
+    <LibraryPath>..\x64\release;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
@@ -159,17 +161,20 @@
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <UseFullPaths>true</UseFullPaths>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-      <LanguageStandard>stdcpp20</LanguageStandard>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <Optimization>MaxSpeed</Optimization>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Framework.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="Array.cpp" />
+    <ClCompile Include="Assembly.cpp" />
     <ClCompile Include="Base64.cpp" />
     <ClCompile Include="Cache.cpp" />
     <ClCompile Include="Json.cpp" />

Framework Tests/Framework Tests.vcxproj.filters

@@ -45,6 +45,9 @@
     <ClCompile Include="Stream.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Assembly.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="pch.h">

Framework Tests/Json.cpp

@@ -460,7 +460,7 @@ namespace FrameworkTests
             jArray->release();
         }
     };
-
+#ifdef DEBUG
     TEST_CLASS (JSONValidatorTests)
     {
     private:
@@ -1002,4 +1002,5 @@ namespace FrameworkTests
     OutputDebugStringBuf<char, std::char_traits<char>>
         JSONValidatorTests::charDebugOutput;
     std::streambuf* JSONValidatorTests::buf;
+#endif
 } // namespace FrameworkTests

Framework.vcxproj

@@ -203,6 +203,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="Animation.h" />
     <ClInclude Include="Animation3D.h" />
     <ClInclude Include="Array.h" />
+    <ClInclude Include="Assembly.h" />
     <ClInclude Include="AsynchronCall.h" />
     <ClInclude Include="AuswahlBox.h" />
     <ClInclude Include="Console.h" />
@@ -311,6 +312,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="AlphaFeld.cpp" />
     <ClCompile Include="Animation.cpp" />
     <ClCompile Include="Animation3D.cpp" />
+    <ClCompile Include="Assembly.cpp" />
     <ClCompile Include="AsynchronCall.cpp" />
     <ClCompile Include="AuswahlBox.cpp" />
     <ClCompile Include="Console.cpp" />

Framework.vcxproj.filters

@@ -62,6 +62,9 @@
     <Filter Include="Framework\Data\Abstract">
       <UniqueIdentifier>{3b8ce08b-1328-41f9-bb01-fea44b107dab}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Framework\Assembly">
+      <UniqueIdentifier>{a20b9fa9-ed63-4ac0-9ba1-998568fdd574}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Model2D.h">
@@ -385,6 +388,9 @@
     <ClInclude Include="DataValidator.h">
       <Filter>Framework\Data\Abstract</Filter>
     </ClInclude>
+    <ClInclude Include="Assembly.h">
+      <Filter>Framework\Assembly</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Model3DCollection.h">
@@ -648,6 +654,9 @@
     <ClCompile Include="AbstractElement.cpp">
       <Filter>Framework\Data\Abstract</Filter>
     </ClCompile>
+    <ClCompile Include="Assembly.cpp">
+      <Filter>Framework\Assembly</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="DX12VertexShader.hlsl">

UIPixelShader.h

@@ -352,10 +352,10 @@ ret
 
 const BYTE UIPixelShader[] =
 {
-     68,  88,  66,  67, 196, 213, 
-     67,  31, 252, 113, 178,  95, 
-    168, 244,  82,  83, 199,  21, 
-    126, 113,   1,   0,   0,   0, 
+     68,  88,  66,  67,   1,  81, 
+    255, 106,  15,  17, 191,  60, 
+    227, 183,  67,  31, 125, 214, 
+    205,  19,   1,   0,   0,   0, 
      12, 134,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
     140,   6,   0,   0,  28,   7, 
@@ -1384,9 +1384,9 @@ const BYTE UIPixelShader[] =
      70,  32,  55,  46,  48,  48, 
      13,  10,  26,  68,  83,   0, 
       0,   0,   0,   2,   0,   0, 
-      1,   0,   0,   0,  55,   0, 
-      0,   0,   0,   1,   0,   0, 
-      0,   0,   0,   0,  52,   0, 
+      2,   0,   0,   0,  55,   0, 
+      0,   0, 248,   0,   0,   0, 
+      0,   0,   0,   0,  51,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1463,8 +1463,7 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 224,   1,   0,   0, 
-      0,   0, 224, 255, 255, 255, 
+      0,   0, 192, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -1548,8 +1547,9 @@ const BYTE UIPixelShader[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  24, 254, 
     255, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255,  56,   0, 
+      0,   0,   0,   0, 240, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -1634,160 +1634,11 @@ const BYTE UIPixelShader[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    101, 114,  84, 101, 120, 116, 
-    117, 114, 101,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40, 116,  48,  41, 
-     59,  13,  10,  83,  97, 109, 
-    112, 108, 101, 114,  83, 116, 
-     97, 116, 101,  32,  83,  97, 
-    109, 112, 108, 101,  84, 121, 
-    112, 101,  59,  13,  10,  13, 
-     10,  47,  47,  32,  84, 104, 
-    101,  32, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32, 111, 
-    102,  32, 116, 104, 101,  32, 
-    107,  97, 109, 101, 114,  97, 
-     13,  10,  99,  98, 117, 102, 
-    102, 101, 114,  32,  75,  97, 
-    109, 101, 114,  97,  32,  58, 
-     32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40,  98,  48, 
-     41,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  52,  32, 107, 
-     80, 111, 115, 105, 116, 105, 
-    111, 110,  59,  13,  10, 125, 
-     13,  10,  13,  10,  47,  47, 
-     32, 116, 104, 101, 115, 101, 
-     32, 118,  97, 108, 117, 101, 
-    115,  32, 115, 104, 111, 117, 
-    108, 100,  32, 115, 117, 109, 
-     32, 117, 112,  32, 116, 111, 
-     32,  49,  13,  10,  99,  98, 
-    117, 102, 102, 101, 114,  32, 
-     77,  97, 116, 101, 114, 105, 
-     97, 108,  32,  58,  32, 114, 
-    101, 103, 105, 115, 116, 101, 
-    114,  40,  98,  49,  41,  13, 
-     10, 123,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  32,  97, 109,  98, 105, 
-    101, 110, 116,  70,  97,  99, 
-    116, 111, 114,  59,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  32, 100, 105, 
-    102, 102, 117, 115,  70,  97, 
-     99, 116, 111, 114,  59,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32, 115, 
-    112, 101,  99, 117, 108,  97, 
-    114,  70,  97,  99, 116, 111, 
-    114,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10,  99,  98, 
-    117, 102, 102, 101, 114,  32, 
-     76, 105, 103, 104, 116,  67, 
-    111, 117, 110, 116,  32,  58, 
-     32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40,  98,  50, 
-     41,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 105, 110, 
-    116,  32, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  67, 111, 117, 110, 
-    116,  59,  13,  10,  32,  32, 
-     32,  32, 105, 110, 116,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116,  67, 111, 
-    117, 110, 116,  59,  13,  10, 
-    125,  13,  10,  13,  10,  47, 
-     47,  32, 108, 105, 103, 104, 
-    116, 115,  13,  10, 115, 116, 
-    114, 117,  99, 116,  32,  68, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  13, 
-     10, 123,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 100, 105, 114, 
-    101,  99, 116, 105, 111, 110, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     51,  32,  99, 111, 108, 111, 
-    114,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10, 115, 116, 
-    114, 117,  99, 116,  32,  80, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,  13,  10, 123, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108,  14, 219,   3,   0, 
-    197,  74,   0,   0, 165, 207, 
-      1,   0, 242,  56,   1,   0, 
-     43, 236,   3,   0,  28,  19, 
-      2,   0,  65,  36,   1,   0, 
-    236, 179,   1,   0, 189, 168, 
-      1,   0, 125,  10,   2,   0, 
-    125, 181,   2,   0, 116, 163, 
-      3,   0, 193,  33,   3,   0, 
-     65, 185,   2,   0,   9, 241, 
-      2,   0, 146, 230,   3,   0, 
-    125, 218,   1,   0, 118,  19, 
-      1,   0, 202, 179,   0,   0, 
-    125, 226,   0,   0, 220, 192, 
-      1,   0, 201, 241,   2,   0, 
-     12, 238,   0,   0,  94, 113, 
-      1,   0, 162, 254,   2,   0, 
-    228, 199,   3,   0, 110,  77, 
-      0,   0, 144, 132,   1,   0, 
-    217, 192,   3,   0,  42, 246, 
-      0,   0, 240, 203,   3,   0, 
-    184, 213,   0,   0,  44, 222, 
-      3,   0, 147,  18,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+      5,   0,   0,   0,  32,   0, 
+      0,   0,  60,   0,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+      6,   0,   0,   0,   5,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1804,17 +1655,8 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 148,  46, 
-     49,   1,   6, 118,  88, 104, 
-      1,   0,   0,   0,  12, 187, 
-     61,  31, 237, 232,  43,  74, 
-    133, 102, 180, 150, 227, 104, 
-    208, 176,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    220,  81,  51,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1877,6 +1719,7 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1890,10 +1733,6 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255, 119,   9, 
-     49,   1,   0,   0,   0,   0, 
-    255, 255,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1965,8 +1804,17 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 148,  46, 
+     49,   1,  77, 224, 173, 104, 
+      1,   0,   0,   0, 123, 114, 
+    161,   2, 247,  51,  29,  75, 
+    162,  24,  41, 116,  18, 220, 
+    128,  57,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    220,  81,  51,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1975,13 +1823,8 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   6,   0,   0,   0, 
-     32,   0,   0,   0,  60,   0, 
       0,   0,   0,   0,   0,   0, 
-     64,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      3,   0,   0,   0,   5,   0, 
-      0,   0,   6,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2047,6 +1890,115 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+    101, 114,  84, 101, 120, 116, 
+    117, 114, 101,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40, 116,  48,  41, 
+     59,  13,  10,  83,  97, 109, 
+    112, 108, 101, 114,  83, 116, 
+     97, 116, 101,  32,  83,  97, 
+    109, 112, 108, 101,  84, 121, 
+    112, 101,  59,  13,  10,  13, 
+     10,  47,  47,  32,  84, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 111, 
+    102,  32, 116, 104, 101,  32, 
+    107,  97, 109, 101, 114,  97, 
+     13,  10,  99,  98, 117, 102, 
+    102, 101, 114,  32,  75,  97, 
+    109, 101, 114,  97,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  98,  48, 
+     41,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  52,  32, 107, 
+     80, 111, 115, 105, 116, 105, 
+    111, 110,  59,  13,  10, 125, 
+     13,  10,  13,  10,  47,  47, 
+     32, 116, 104, 101, 115, 101, 
+     32, 118,  97, 108, 117, 101, 
+    115,  32, 115, 104, 111, 117, 
+    108, 100,  32, 115, 117, 109, 
+     32, 117, 112,  32, 116, 111, 
+     32,  49,  13,  10,  99,  98, 
+    117, 102, 102, 101, 114,  32, 
+     77,  97, 116, 101, 114, 105, 
+     97, 108,  32,  58,  32, 114, 
+    101, 103, 105, 115, 116, 101, 
+    114,  40,  98,  49,  41,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  32,  97, 109,  98, 105, 
+    101, 110, 116,  70,  97,  99, 
+    116, 111, 114,  59,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  32, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 115, 
+    112, 101,  99, 117, 108,  97, 
+    114,  70,  97,  99, 116, 111, 
+    114,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  99,  98, 
+    117, 102, 102, 101, 114,  32, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  98,  50, 
+     41,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32, 105, 110, 
+    116,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,  59,  13,  10,  32,  32, 
+     32,  32, 105, 110, 116,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116,  67, 111, 
+    117, 110, 116,  59,  13,  10, 
+    125,  13,  10,  13,  10,  47, 
+     47,  32, 108, 105, 103, 104, 
+    116, 115,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  68, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  51,  32, 100, 105, 114, 
+    101,  99, 116, 105, 111, 110, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     51,  32,  99, 111, 108, 111, 
+    114,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  80, 
+    111, 105, 110, 116,  76, 105, 
+    103, 104, 116,  13,  10, 123, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 198,  90,   0,   0, 
+    117, 131,   1,   0,  76, 232, 
+      3,   0, 242,  56,   1,   0, 
+     43, 236,   3,   0,  28,  19, 
+      2,   0,  65,  36,   1,   0, 
+    236, 179,   1,   0,  34, 187, 
+      3,   0, 125,  10,   2,   0, 
+    125, 181,   2,   0,  88, 145, 
+      2,   0, 193,  33,   3,   0, 
+     65, 185,   2,   0,   9, 241, 
+      2,   0, 146, 230,   3,   0, 
+    125, 218,   1,   0, 118,  19, 
+      1,   0, 202, 179,   0,   0, 
+    125, 226,   0,   0, 220, 192, 
+      1,   0, 201, 241,   2,   0, 
+     12, 238,   0,   0, 218, 152, 
+      2,   0, 162, 254,   2,   0, 
+    228, 199,   3,   0, 110,  77, 
+      0,   0, 144, 132,   1,   0, 
+    103, 185,   1,   0,  42, 246, 
+      0,   0, 240, 203,   3,   0, 
+    187,  26,   0,   0,  44, 222, 
+      3,   0, 147,  18,   0,   0, 
+      0,  16,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2060,7 +2012,6 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   7,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2109,46 +2060,9 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     47,  47,  47,  47,  47,  47, 
+      0,   0,   0,   0,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  32,  32,  32,  32,  32, 
+     47,  47,  47,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2163,10 +2077,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  71,  76,  79,  66,  65, 
-     76,  83,  32,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  32,  71, 
+     76,  79,  66,  65,  76,  83, 
+     32,  47,  47,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2181,9 +2095,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  47,  47, 
+     32,  32,  32,  32,  13,  10, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  32,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2198,152 +2113,152 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     84, 101, 120, 116, 117, 114, 
-    101,  50,  68,  32, 115, 104, 
-     97, 100, 101, 114,  84, 101, 
-    120, 116, 117, 114, 101,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40, 116, 
-     48,  41,  59,  13,  10,  83, 
-     97, 109, 112, 108, 101, 114, 
-     83, 116,  97, 116, 101,  32, 
-     83,  97, 109, 112, 108, 101, 
-     84, 121, 112, 101,  59,  13, 
-     10,  13,  10,  47,  47,  32, 
-     84, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 111, 102,  32, 116, 104, 
-    101,  32, 107,  97, 109, 101, 
-    114,  97,  13,  10,  99,  98, 
-    117, 102, 102, 101, 114,  32, 
-     75,  97, 109, 101, 114,  97, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     98,  48,  41,  13,  10, 123, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  52, 
-     32, 107,  80, 111, 115, 105, 
-    116, 105, 111, 110,  59,  13, 
-     10, 125,  13,  10,  13,  10, 
-     47,  47,  32, 116, 104, 101, 
-    115, 101,  32, 118,  97, 108, 
-    117, 101, 115,  32, 115, 104, 
-    111, 117, 108, 100,  32, 115, 
-    117, 109,  32, 117, 112,  32, 
-    116, 111,  32,  49,  13,  10, 
-     99,  98, 117, 102, 102, 101, 
-    114,  32,  77,  97, 116, 101, 
-    114, 105,  97, 108,  32,  58, 
+     32,  32,  13,  10,  84, 101, 
+    120, 116, 117, 114, 101,  50, 
+     68,  32, 115, 104,  97, 100, 
+    101, 114,  84, 101, 120, 116, 
+    117, 114, 101,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40, 116,  48,  41, 
+     59,  13,  10,  83,  97, 109, 
+    112, 108, 101, 114,  83, 116, 
+     97, 116, 101,  32,  83,  97, 
+    109, 112, 108, 101,  84, 121, 
+    112, 101,  59,  13,  10,  13, 
+     10,  47,  47,  32,  84, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 111, 
+    102,  32, 116, 104, 101,  32, 
+    107,  97, 109, 101, 114,  97, 
+     13,  10,  99,  98, 117, 102, 
+    102, 101, 114,  32,  75,  97, 
+    109, 101, 114,  97,  32,  58, 
      32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40,  98,  49, 
+    116, 101, 114,  40,  98,  48, 
      41,  13,  10, 123,  13,  10, 
      32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  32,  97, 109, 
-     98, 105, 101, 110, 116,  70, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  32, 
-    100, 105, 102, 102, 117, 115, 
-     70,  97,  99, 116, 111, 114, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     32, 115, 112, 101,  99, 117, 
-    108,  97, 114,  70,  97,  99, 
+    111,  97, 116,  52,  32, 107, 
+     80, 111, 115, 105, 116, 105, 
+    111, 110,  59,  13,  10, 125, 
+     13,  10,  13,  10,  47,  47, 
+     32, 116, 104, 101, 115, 101, 
+     32, 118,  97, 108, 117, 101, 
+    115,  32, 115, 104, 111, 117, 
+    108, 100,  32, 115, 117, 109, 
+     32, 117, 112,  32, 116, 111, 
+     32,  49,  13,  10,  99,  98, 
+    117, 102, 102, 101, 114,  32, 
+     77,  97, 116, 101, 114, 105, 
+     97, 108,  32,  58,  32, 114, 
+    101, 103, 105, 115, 116, 101, 
+    114,  40,  98,  49,  41,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  32,  97, 109,  98, 105, 
+    101, 110, 116,  70,  97,  99, 
     116, 111, 114,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
-     99,  98, 117, 102, 102, 101, 
-    114,  32,  76, 105, 103, 104, 
-    116,  67, 111, 117, 110, 116, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     98,  50,  41,  13,  10, 123, 
-     13,  10,  32,  32,  32,  32, 
-    105, 110, 116,  32, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  32, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 115, 
+    112, 101,  99, 117, 108,  97, 
+    114,  70,  97,  99, 116, 111, 
+    114,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  99,  98, 
+    117, 102, 102, 101, 114,  32, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  98,  50, 
+     41,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32, 105, 110, 
+    116,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,  59,  13,  10,  32,  32, 
+     32,  32, 105, 110, 116,  32, 
+    112, 111, 105, 110, 116,  76, 
     105, 103, 104, 116,  67, 111, 
     117, 110, 116,  59,  13,  10, 
-     32,  32,  32,  32, 105, 110, 
-    116,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-     67, 111, 117, 110, 116,  59, 
-     13,  10, 125,  13,  10,  13, 
-     10,  47,  47,  32, 108, 105, 
-    103, 104, 116, 115,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  68, 105, 102, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
-    116,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  51,  32, 100, 
-    105, 114, 101,  99, 116, 105, 
-    111, 110,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  51,  32,  99, 111, 
-    108, 111, 114,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  80, 111, 105, 110, 116, 
+    125,  13,  10,  13,  10,  47, 
+     47,  32, 108, 105, 103, 104, 
+    116, 115,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  68, 
+    105, 102, 102, 117, 115, 101, 
      76, 105, 103, 104, 116,  13, 
      10, 123,  13,  10,  32,  32, 
      32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 112, 111, 115, 
-    105, 116, 105, 111, 110,  59, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  51, 
-     32,  99, 111, 108, 111, 114, 
+    116,  51,  32, 100, 105, 114, 
+    101,  99, 116, 105, 111, 110, 
      59,  13,  10,  32,  32,  32, 
      32, 102, 108, 111,  97, 116, 
-     32, 114,  97, 100, 105, 117, 
-    115,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10,  99,  98, 
-    117, 102, 102, 101, 114,  32, 
-     84, 101, 120, 116, 117, 114, 
-     69, 102, 102, 101,  99, 116, 
-     32,  58,  32, 114, 101, 103, 
-    105, 115, 116, 101, 114,  40, 
-     98,  51,  41,  13,  10, 123, 
+     51,  32,  99, 111, 108, 111, 
+    114,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  80, 
+    111, 105, 110, 116,  76, 105, 
+    103, 104, 116,  13,  10, 123, 
      13,  10,  32,  32,  32,  32, 
-     98, 111, 111, 108,  32, 101, 
-    102, 102, 101,  99, 116,  69, 
-    110,  97,  98, 108, 101, 100, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     32, 101, 102, 102, 101,  99, 
-    116,  80, 101, 114,  99, 101, 
-    110, 116,  97, 103, 101,  59, 
+    102, 108, 111,  97, 116,  51, 
+     32, 112, 111, 115, 105, 116, 
+    105, 111, 110,  59,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  51,  32,  99, 
+    111, 108, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 114, 
+     97, 100, 105, 117, 115,  59, 
      13,  10, 125,  59,  13,  10, 
-     13,  10,  83, 116, 114, 117, 
-     99, 116, 117, 114, 101, 100, 
-     66, 117, 102, 102, 101, 114, 
-     60,  32,  68, 105, 102, 102, 
+     13,  10,  99,  98, 117, 102, 
+    102, 101, 114,  32,  84, 101, 
+    120, 116, 117, 114,  69, 102, 
+    102, 101,  99, 116,  32,  58, 
+     32, 114, 101, 103, 105, 115, 
+    116, 101, 114,  40,  98,  51, 
+     41,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32,  98, 111, 
+    111, 108,  32, 101, 102, 102, 
+    101,  99, 116,  69, 110,  97, 
+     98, 108, 101, 100,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  32, 101, 
+    102, 102, 101,  99, 116,  80, 
+    101, 114,  99, 101, 110, 116, 
+     97, 103, 101,  59,  13,  10, 
+    125,  59,  13,  10,  13,  10, 
+     83, 116, 114, 117,  99, 116, 
+    117, 114, 101, 100,  66, 117, 
+    102, 102, 101, 114,  60,  32, 
+     68, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     32,  62,  32, 100, 105, 102, 
     117, 115, 101,  76, 105, 103, 
-    104, 116,  32,  62,  32, 100, 
-    105, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116, 115,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40, 116, 
-     49,  41,  59,  13,  10,  83, 
-    116, 114, 117,  99, 116, 117, 
-    114, 101, 100,  66, 117, 102, 
-    102, 101, 114,  60,  32,  80, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,  32,  62,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116, 115,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40, 116, 
-     50,  41,  59,  13,  10,  84, 
+    104, 116, 115,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40, 116,  49,  41, 
+     59,  13,  10,  83, 116, 114, 
+    117,  99, 116, 117, 114, 101, 
+    100,  66, 117, 102, 102, 101, 
+    114,  60,  32,  80, 111, 105, 
+    110, 116,  76, 105, 103, 104, 
+    116,  32,  62,  32, 112, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116, 115,  32,  58,  32, 
+    114, 101, 103, 105, 115, 116, 
+    101, 114,  40, 116,  50,  41, 
+     59,  13,  10,  84, 101, 120, 
+    116, 117, 114, 101,  50,  68, 
+     32,  97, 100, 100, 105, 116, 
+    105, 111, 110,  97, 108,  84, 
     101, 120, 116, 117, 114, 101, 
-     50,  68,  32,  97, 100, 100, 
-    105, 116, 105, 111, 110,  97, 
-    108,  84, 101, 120, 116, 117, 
-    114, 101,  32,  58,  32, 114, 
-    101, 103, 105, 115, 116, 101, 
-    114,  40, 116,  51,  41,  59, 
-     13,  10,  13,  10,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
+     32,  58,  32, 114, 101, 103, 
+    105, 115, 116, 101, 114,  40, 
+    116,  51,  41,  59,  13,  10, 
+     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2358,10 +2273,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  32,  84, 
-     89,  80,  69,  68,  69,  70, 
-     83,  32,  47,  47,  32,  32, 
+     32,  32,  32,  32,  13,  10, 
+     47,  47,  32,  84,  89,  80, 
+     69,  68,  69,  70,  83,  32, 
+     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2376,10 +2291,9 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
+     32,  32,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2394,35 +2308,35 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10, 115, 116, 
-    114, 117,  99, 116,  32,  80, 
-    105, 120, 101, 108,  73, 110, 
-    112, 117, 116,  84, 121, 112, 
-    101,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32,  32,  32, 
+     13,  10, 115, 116, 114, 117, 
+     99, 116,  32,  80, 105, 120, 
+    101, 108,  73, 110, 112, 117, 
+    116,  84, 121, 112, 101,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  52,  32, 119, 111, 114, 
+    108, 100,  80, 111, 115,  32, 
+     58,  32,  80,  79,  83,  73, 
+     84,  73,  79,  78,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  52,  32, 
+    112, 111, 115, 105, 116, 105, 
+    111, 110,  32,  58,  32,  83, 
+     86,  95,  80,  79,  83,  73, 
+     84,  73,  79,  78,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  50,  32, 
+    116, 101, 120,  32,  58,  32, 
+     84,  69,  88,  67,  79,  79, 
+     82,  68,  48,  59,  13,  10, 
      32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  52,  32, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,  32,  58,  32,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     52,  32, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  58, 
-     32,  83,  86,  95,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     50,  32, 116, 101, 120,  32, 
+    111,  97, 116,  51,  32, 110, 
+    111, 114, 109,  97, 108,  32, 
      58,  32,  84,  69,  88,  67, 
-     79,  79,  82,  68,  48,  59, 
-     13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  51, 
-     32, 110, 111, 114, 109,  97, 
-    108,  32,  58,  32,  84,  69, 
-     88,  67,  79,  79,  82,  68, 
-     49,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
+     79,  79,  82,  68,  49,  59, 
+     13,  10, 125,  59,  13,  10, 
+     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -2435,13 +2349,14 @@ const BYTE UIPixelShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  32,  80, 
-    105, 120, 101, 108,  32,  83, 
-    104,  97, 100, 101, 114,  32, 
+     32,  32,  32,  32,  13,  10, 
+     47,  47,  32,  80, 105, 120, 
+    101, 108,  32,  83, 104,  97, 
+    100, 101, 114,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2456,7 +2371,7 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
+     32,  32,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -2470,70 +2385,48 @@ const BYTE UIPixelShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10, 102, 108, 
-    111,  97, 116,  52,  32,  84, 
-    101, 120, 116, 117, 114, 101, 
-     80, 105, 120, 101, 108,  83, 
-    104,  97, 100, 101, 114,  40, 
-     32,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 105, 110, 
-    112, 117, 116,  32,  41,  32, 
-     58,  32,  83,  86,  95,  84, 
-     65,  82,  71,  69,  84,  13, 
-     10, 123,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  32,  61,  32, 
-    102, 108, 111,  97, 116,  51, 
-     40,  48,  44,  32,  48,  44, 
-     32,  48,  41,  59,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  51,  32, 115, 
-    112, 101,  99, 117, 108,  97, 
-    114,  76, 105, 103, 104, 116, 
-     32,  61,  32, 102, 108, 111, 
-     97, 116,  51,  40,  48,  44, 
-     32,  48,  44,  32,  48,  41, 
-     59,  13,  10,  32,  32,  32, 
-     32, 102, 111, 114,  40,  32, 
-    105, 110, 116,  32, 106,  32, 
-     61,  32,  48,  59,  32, 106, 
-     32,  60,  32, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  59,  32, 106,  43, 
-     43,  32,  41,  13,  10,  32, 
-     32,  32,  32, 123,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 105, 102,  40,  32, 
-    100, 111, 116,  40,  32, 105, 
-    110, 112, 117, 116,  46, 110, 
-    111, 114, 109,  97, 108,  44, 
-     32,  45, 100, 105, 102, 117, 
+     13,  10, 102, 108, 111,  97, 
+    116,  52,  32,  84, 101, 120, 
+    116, 117, 114, 101,  80, 105, 
+    120, 101, 108,  83, 104,  97, 
+    100, 101, 114,  40,  32,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 105, 110, 112, 117, 
+    116,  32,  41,  32,  58,  32, 
+     83,  86,  95,  84,  65,  82, 
+     71,  69,  84,  13,  10, 123, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 111,  97, 116,  51, 
+     32, 100, 105, 102, 102, 117, 
     115, 101,  76, 105, 103, 104, 
-    116, 115,  91,  32, 106,  32, 
-     93,  46, 100, 105, 114, 101, 
-     99, 116, 105, 111, 110,  32, 
-     41,  32,  60,  32,  48,  32, 
+    116,  32,  61,  32, 102, 108, 
+    111,  97, 116,  51,  40,  48, 
+     44,  32,  48,  44,  32,  48, 
+     41,  59,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  51,  32, 115, 112, 101, 
+     99, 117, 108,  97, 114,  76, 
+    105, 103, 104, 116,  32,  61, 
+     32, 102, 108, 111,  97, 116, 
+     51,  40,  48,  44,  32,  48, 
+     44,  32,  48,  41,  59,  13, 
+     10,  32,  32,  32,  32, 102, 
+    111, 114,  40,  32, 105, 110, 
+    116,  32, 106,  32,  61,  32, 
+     48,  59,  32, 106,  32,  60, 
+     32, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  67, 111, 117, 110, 116, 
+     59,  32, 106,  43,  43,  32, 
      41,  13,  10,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  99, 111, 110, 
-    116, 105, 110, 117, 101,  59, 
-     13,  10,  32,  32,  32,  32, 
-     32,  32,  32,  32, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  32,  43, 
-     61,  32, 100, 105, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
-    116, 115,  91,  32, 106,  32, 
-     93,  46,  99, 111, 108, 111, 
-    114,  32,  42,  32, 100, 111, 
+    105, 102,  40,  32, 100, 111, 
     116,  40,  32, 105, 110, 112, 
     117, 116,  46, 110, 111, 114, 
     109,  97, 108,  44,  32,  45, 
@@ -2541,406 +2434,427 @@ const BYTE UIPixelShader[] =
      76, 105, 103, 104, 116, 115, 
      91,  32, 106,  32,  93,  46, 
     100, 105, 114, 101,  99, 116, 
-    105, 111, 110,  32,  41,  59, 
-     13,  10,  32,  32,  32,  32, 
-    125,  13,  10,  32,  32,  32, 
-     32, 102, 111, 114,  40,  32, 
-    105, 110, 116,  32, 105,  32, 
-     61,  32,  48,  59,  32, 105, 
-     32,  60,  32, 112, 111, 105, 
-    110, 116,  76, 105, 103, 104, 
-    116,  67, 111, 117, 110, 116, 
-     59,  32, 105,  43,  43,  32, 
-     41,  13,  10,  32,  32,  32, 
-     32, 123,  13,  10,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  51, 
-     32, 108, 105, 103, 104, 116, 
-     68, 105, 114,  32,  61,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116, 115,  91, 
-     32, 105,  32,  93,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  45,  32, 105, 110, 
-    112, 117, 116,  46, 119, 111, 
-    114, 108, 100,  80, 111, 115, 
-     46, 120, 121, 122,  59,  13, 
+    105, 111, 110,  32,  41,  32, 
+     60,  32,  48,  32,  41,  13, 
      10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32, 102,  97,  99, 
-    116, 111, 114,  59,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 105, 102,  40,  32, 
-    108, 101, 110, 103, 116, 104, 
-     40,  32, 108, 105, 103, 104, 
-    116,  68, 105, 114,  32,  41, 
-     32,  60,  32,  49,  32,  41, 
+     32,  99, 111, 110, 116, 105, 
+    110, 117, 101,  59,  13,  10, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  32,  43,  61,  32, 
+    100, 105, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116, 115, 
+     91,  32, 106,  32,  93,  46, 
+     99, 111, 108, 111, 114,  32, 
+     42,  32, 100, 111, 116,  40, 
+     32, 105, 110, 112, 117, 116, 
+     46, 110, 111, 114, 109,  97, 
+    108,  44,  32,  45, 100, 105, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116, 115,  91,  32, 
+    106,  32,  93,  46, 100, 105, 
+    114, 101,  99, 116, 105, 111, 
+    110,  32,  41,  59,  13,  10, 
+     32,  32,  32,  32, 125,  13, 
+     10,  32,  32,  32,  32, 102, 
+    111, 114,  40,  32, 105, 110, 
+    116,  32, 105,  32,  61,  32, 
+     48,  59,  32, 105,  32,  60, 
+     32, 112, 111, 105, 110, 116, 
+     76, 105, 103, 104, 116,  67, 
+    111, 117, 110, 116,  59,  32, 
+    105,  43,  43,  32,  41,  13, 
+     10,  32,  32,  32,  32, 123, 
      13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  51,  32, 108, 
+    105, 103, 104, 116,  68, 105, 
+    114,  32,  61,  32, 112, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116, 115,  91,  32, 105, 
+     32,  93,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+     45,  32, 105, 110, 112, 117, 
+    116,  46, 119, 111, 114, 108, 
+    100,  80, 111, 115,  46, 120, 
+    121, 122,  59,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 102,  97,  99, 116, 
-    111, 114,  32,  61,  32,  49, 
-     59,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 101, 
-    108, 115, 101,  13,  10,  32, 
+     32, 102, 108, 111,  97, 116, 
+     32, 102,  97,  99, 116, 111, 
+    114,  59,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32, 102, 
-     97,  99, 116, 111, 114,  32, 
-     61,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-    115,  91,  32, 105,  32,  93, 
-     46, 114,  97, 100, 105, 117, 
-    115,  32,  47,  32, 108, 101, 
+    105, 102,  40,  32, 108, 101, 
     110, 103, 116, 104,  40,  32, 
     108, 105, 103, 104, 116,  68, 
-    105, 114,  32,  41,  59,  13, 
-     10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32, 102,  32,  61, 
-     32, 100, 111, 116,  40,  32, 
-    105, 110, 112, 117, 116,  46, 
-    110, 111, 114, 109,  97, 108, 
-     44,  32, 110, 111, 114, 109, 
-     97, 108, 105, 122, 101,  40, 
-     32, 108, 105, 103, 104, 116, 
-     68, 105, 114,  32,  41,  32, 
-     41,  59,  13,  10,  32,  32, 
+    105, 114,  32,  41,  32,  60, 
+     32,  49,  32,  41,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-    105, 102,  40,  32, 102,  32, 
-     62,  32,  48,  32,  41,  13, 
+     32,  32,  32,  32,  32,  32, 
+    102,  97,  99, 116, 111, 114, 
+     32,  61,  32,  49,  59,  13, 
      10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 123,  13,  10, 
+     32,  32,  32, 101, 108, 115, 
+    101,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32, 102,  97,  99, 
+    116, 111, 114,  32,  61,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  91, 
+     32, 105,  32,  93,  46, 114, 
+     97, 100, 105, 117, 115,  32, 
+     47,  32, 108, 101, 110, 103, 
+    116, 104,  40,  32, 108, 105, 
+    103, 104, 116,  68, 105, 114, 
+     32,  41,  59,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     32, 102,  32,  61,  32, 100, 
+    111, 116,  40,  32, 105, 110, 
+    112, 117, 116,  46, 110, 111, 
+    114, 109,  97, 108,  44,  32, 
+    110, 111, 114, 109,  97, 108, 
+    105, 122, 101,  40,  32, 108, 
+    105, 103, 104, 116,  68, 105, 
+    114,  32,  41,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32, 105, 102, 
+     40,  32, 102,  32,  62,  32, 
+     48,  32,  41,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     32,  43,  61,  32, 112, 111, 
-    105, 110, 116,  76, 105, 103, 
-    104, 116, 115,  91,  32, 105, 
-     32,  93,  46,  99, 111, 108, 
-    111, 114,  32,  42,  32, 102, 
-     32,  42,  32, 102,  97,  99, 
-    116, 111, 114,  59,  13,  10, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116,  32,  43, 
+     61,  32, 112, 111, 105, 110, 
+    116,  76, 105, 103, 104, 116, 
+    115,  91,  32, 105,  32,  93, 
+     46,  99, 111, 108, 111, 114, 
+     32,  42,  32, 102,  32,  42, 
+     32, 102,  97,  99, 116, 111, 
+    114,  59,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-    102,  32,  61,  32, 100, 111, 
+     32,  32,  32,  32, 102,  32, 
+     61,  32, 100, 111, 116,  40, 
+     32, 110, 111, 114, 109,  97, 
+    108, 105, 122, 101,  40,  32, 
+    114, 101, 102, 108, 101,  99, 
     116,  40,  32, 110, 111, 114, 
     109,  97, 108, 105, 122, 101, 
-     40,  32, 114, 101, 102, 108, 
-    101,  99, 116,  40,  32, 110, 
-    111, 114, 109,  97, 108, 105, 
-    122, 101,  40,  32,  45, 108, 
-    105, 103, 104, 116,  68, 105, 
-    114,  32,  41,  44,  32, 105, 
-    110, 112, 117, 116,  46, 110, 
-    111, 114, 109,  97, 108,  32, 
-     41,  32,  41,  44,  32, 110, 
-    111, 114, 109,  97, 108, 105, 
-    122, 101,  40,  32, 107,  80, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 120, 121, 122,  32, 
-     45,  32, 105, 110, 112, 117, 
-    116,  46, 119, 111, 114, 108, 
-    100,  80, 111, 115,  46, 120, 
-    121, 122,  32,  41,  32,  41, 
-     59,  13,  10,  32,  32,  32, 
+     40,  32,  45, 108, 105, 103, 
+    104, 116,  68, 105, 114,  32, 
+     41,  44,  32, 105, 110, 112, 
+    117, 116,  46, 110, 111, 114, 
+    109,  97, 108,  32,  41,  32, 
+     41,  44,  32, 110, 111, 114, 
+    109,  97, 108, 105, 122, 101, 
+     40,  32, 107,  80, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    120, 121, 122,  32,  45,  32, 
+    105, 110, 112, 117, 116,  46, 
+    119, 111, 114, 108, 100,  80, 
+    111, 115,  46, 120, 121, 122, 
+     32,  41,  32,  41,  59,  13, 
+     10,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32, 105, 102,  40, 
-     32, 102,  32,  62,  32,  48, 
-     32,  41,  13,  10,  32,  32, 
+     32, 105, 102,  40,  32, 102, 
+     32,  62,  32,  48,  32,  41, 
+     13,  10,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 115, 112, 101,  99, 
-    117, 108,  97, 114,  76, 105, 
-    103, 104, 116,  32,  43,  61, 
-     32, 112, 111, 105, 110, 116, 
-     76, 105, 103, 104, 116, 115, 
-     91,  32, 105,  32,  93,  46, 
-     99, 111, 108, 111, 114,  32, 
-     42,  32, 102,  32,  42,  32, 
-    102,  97,  99, 116, 111, 114, 
-     59,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 125, 
-     13,  10,  32,  32,  32,  32, 
-    125,  13,  10,  32,  32,  32, 
-     32,  47,  47, 105, 102,  32, 
-     40,  33,  40, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  32, 
-     62,  61,  32,  48,  32,  38, 
-     38,  32, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  46, 120,  32,  60, 
-     61,  32,  49,  41,  41,  13, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  76, 105, 103, 104, 
+    116,  32,  43,  61,  32, 112, 
+    111, 105, 110, 116,  76, 105, 
+    103, 104, 116, 115,  91,  32, 
+    105,  32,  93,  46,  99, 111, 
+    108, 111, 114,  32,  42,  32, 
+    102,  32,  42,  32, 102,  97, 
+     99, 116, 111, 114,  59,  13, 
+     10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 125,  13,  10, 
+     32,  32,  32,  32, 125,  13, 
      10,  32,  32,  32,  32,  47, 
-     47,   9, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  46, 120,  32,  61, 
-     32,  48,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  52,  32, 109,  97, 
-    116, 101, 114, 105,  97, 108, 
-     67, 111, 108, 111, 114,  32, 
-     61,  32, 115, 104,  97, 100, 
-    101, 114,  84, 101, 120, 116, 
-    117, 114, 101,  46,  83,  97, 
-    109, 112, 108, 101,  40,  32, 
-     83,  97, 109, 112, 108, 101, 
-     84, 121, 112, 101,  44,  32, 
-    105, 110, 112, 117, 116,  46, 
-    116, 101, 120,  32,  41,  59, 
+     47, 105, 102,  32,  40,  33, 
+     40, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  46, 120,  32,  62,  61, 
+     32,  48,  32,  38,  38,  32, 
+    100, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     46, 120,  32,  60,  61,  32, 
+     49,  41,  41,  13,  10,  32, 
+     32,  32,  32,  47,  47,   9, 
+    100, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     46, 120,  32,  61,  32,  48, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     52,  32, 109,  97, 116, 101, 
+    114, 105,  97, 108,  67, 111, 
+    108, 111, 114,  32,  61,  32, 
+    115, 104,  97, 100, 101, 114, 
+     84, 101, 120, 116, 117, 114, 
+    101,  46,  83,  97, 109, 112, 
+    108, 101,  40,  32,  83,  97, 
+    109, 112, 108, 101,  84, 121, 
+    112, 101,  44,  32, 105, 110, 
+    112, 117, 116,  46, 116, 101, 
+    120,  32,  41,  59,  13,  10, 
+     32,  32,  32,  32, 105, 102, 
+     40,  32, 101, 102, 102, 101, 
+     99, 116,  69, 110,  97,  98, 
+    108, 101, 100,  32,  41,  13, 
+     10,  32,  32,  32,  32, 123, 
      13,  10,  32,  32,  32,  32, 
-    105, 102,  40,  32, 101, 102, 
-    102, 101,  99, 116,  69, 110, 
-     97,  98, 108, 101, 100,  32, 
-     41,  13,  10,  32,  32,  32, 
-     32, 123,  13,  10,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  32, 
-    100, 105, 115, 116,  32,  61, 
-     32, 115, 113, 114, 116,  40, 
-     32,  40, 105, 110, 112, 117, 
-    116,  46, 116, 101, 120,  46, 
-    120,  32,  45,  32,  48,  46, 
-     53, 102,  41,  32,  42,  32, 
-     40, 105, 110, 112, 117, 116, 
-     46, 116, 101, 120,  46, 120, 
-     32,  45,  32,  48,  46,  53, 
-    102,  41,  32,  43,  32,  40, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  32, 100, 105, 
+    115, 116,  32,  61,  32, 115, 
+    113, 114, 116,  40,  32,  40, 
     105, 110, 112, 117, 116,  46, 
-    116, 101, 120,  46, 121,  32, 
+    116, 101, 120,  46, 120,  32, 
      45,  32,  48,  46,  53, 102, 
      41,  32,  42,  32,  40, 105, 
     110, 112, 117, 116,  46, 116, 
-    101, 120,  46, 121,  32,  45, 
+    101, 120,  46, 120,  32,  45, 
      32,  48,  46,  53, 102,  41, 
-     32,  41,  32,  47,  32, 115, 
-    113, 114, 116,  40,  32,  48, 
-     46,  53, 102,  32,  41,  59, 
+     32,  43,  32,  40, 105, 110, 
+    112, 117, 116,  46, 116, 101, 
+    120,  46, 121,  32,  45,  32, 
+     48,  46,  53, 102,  41,  32, 
+     42,  32,  40, 105, 110, 112, 
+    117, 116,  46, 116, 101, 120, 
+     46, 121,  32,  45,  32,  48, 
+     46,  53, 102,  41,  32,  41, 
+     32,  47,  32, 115, 113, 114, 
+    116,  40,  32,  48,  46,  53, 
+    102,  32,  41,  59,  13,  10, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32, 105, 102,  40,  32, 
+    100, 105, 115, 116,  32,  60, 
+     32, 101, 102, 102, 101,  99, 
+    116,  80, 101, 114,  99, 101, 
+    110, 116,  97, 103, 101,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 123, 
      13,  10,  32,  32,  32,  32, 
-     32,  32,  32,  32, 105, 102, 
-     40,  32, 100, 105, 115, 116, 
-     32,  60,  32, 101, 102, 102, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  32,  97, 108, 112, 104, 
+     97,  77, 117, 108, 116, 105, 
+    112, 108, 105, 101, 114,  32, 
+     61,  32,  40, 101, 102, 102, 
     101,  99, 116,  80, 101, 114, 
      99, 101, 110, 116,  97, 103, 
-    101,  32,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32, 123,  13,  10,  32,  32, 
+    101,  32,  45,  32, 100, 105, 
+    115, 116,  41,  32,  47,  32, 
+     48,  46,  50, 102,  59,  13, 
+     10,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  32,  97, 108, 
-    112, 104,  97,  77, 117, 108, 
-    116, 105, 112, 108, 105, 101, 
-    114,  32,  61,  32,  40, 101, 
-    102, 102, 101,  99, 116,  80, 
-    101, 114,  99, 101, 110, 116, 
-     97, 103, 101,  32,  45,  32, 
-    100, 105, 115, 116,  41,  32, 
-     47,  32,  48,  46,  50, 102, 
-     59,  13,  10,  32,  32,  32, 
+     32, 105, 102,  40,  32,  97, 
+    108, 112, 104,  97,  77, 117, 
+    108, 116, 105, 112, 108, 105, 
+    101, 114,  32,  62,  32,  49, 
+     32,  41,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32, 105, 102,  40, 
-     32,  97, 108, 112, 104,  97, 
-     77, 117, 108, 116, 105, 112, 
-    108, 105, 101, 114,  32,  62, 
-     32,  49,  32,  41,  13,  10, 
      32,  32,  32,  32,  32,  32, 
+     32,  32,  97, 108, 112, 104, 
+     97,  77, 117, 108, 116, 105, 
+    112, 108, 105, 101, 114,  32, 
+     61,  32,  49,  46, 102,  59, 
+     13,  10,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  97, 108, 
-    112, 104,  97,  77, 117, 108, 
-    116, 105, 112, 108, 105, 101, 
-    114,  32,  61,  32,  49,  46, 
-    102,  59,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  52,  32, 101, 102, 102, 
+    101,  99, 116,  67, 111, 108, 
+    111, 114,  32,  61,  32,  97, 
+    100, 100, 105, 116, 105, 111, 
+    110,  97, 108,  84, 101, 120, 
+    116, 117, 114, 101,  46,  83, 
+     97, 109, 112, 108, 101,  40, 
+     32,  83,  97, 109, 112, 108, 
+    101,  84, 121, 112, 101,  44, 
+     32, 105, 110, 112, 117, 116, 
+     46, 116, 101, 120,  32,  41, 
+     59,  13,  10,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  52,  32, 101, 
-    102, 102, 101,  99, 116,  67, 
+     32,  32,  32, 109,  97, 116, 
+    101, 114, 105,  97, 108,  67, 
     111, 108, 111, 114,  32,  61, 
-     32,  97, 100, 100, 105, 116, 
-    105, 111, 110,  97, 108,  84, 
-    101, 120, 116, 117, 114, 101, 
-     46,  83,  97, 109, 112, 108, 
-    101,  40,  32,  83,  97, 109, 
-    112, 108, 101,  84, 121, 112, 
-    101,  44,  32, 105, 110, 112, 
-    117, 116,  46, 116, 101, 120, 
-     32,  41,  59,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32, 109, 
-     97, 116, 101, 114, 105,  97, 
-    108,  67, 111, 108, 111, 114, 
-     32,  61,  32, 101, 102, 102, 
-    101,  99, 116,  67, 111, 108, 
-    111, 114,  32,  42,  32,  40, 
+     32, 101, 102, 102, 101,  99, 
+    116,  67, 111, 108, 111, 114, 
+     32,  42,  32,  40, 101, 102, 
+    102, 101,  99, 116,  67, 111, 
+    108, 111, 114,  46,  97,  32, 
+     42,  32,  97, 108, 112, 104, 
+     97,  77, 117, 108, 116, 105, 
+    112, 108, 105, 101, 114,  41, 
+     32,  43,  32, 109,  97, 116, 
+    101, 114, 105,  97, 108,  67, 
+    111, 108, 111, 114,  32,  42, 
+     32,  40,  49,  32,  45,  32, 
     101, 102, 102, 101,  99, 116, 
      67, 111, 108, 111, 114,  46, 
      97,  32,  42,  32,  97, 108, 
     112, 104,  97,  77, 117, 108, 
     116, 105, 112, 108, 105, 101, 
-    114,  41,  32,  43,  32, 109, 
+    114,  41,  59,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32, 125,  13,  10,  32,  32, 
+     32,  32, 125,  13,  10,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  52,  32, 116, 101, 
+    120, 116, 117, 114, 101,  67, 
+    111, 108, 111, 114,  32,  61, 
+     32, 115,  97, 116, 117, 114, 
+     97, 116, 101,  40,  32,  40, 
+    109,  97, 116, 101, 114, 105, 
+     97, 108,  67, 111, 108, 111, 
+    114,  32,  42,  32,  97, 109, 
+     98, 105, 101, 110, 116,  70, 
+     97,  99, 116, 111, 114,  41, 
+     32,  43,  32,  40, 102, 108, 
+    111,  97, 116,  52,  40, 100, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  46, 
+    120,  44,  32, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  46, 121,  44, 
+     32, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  46, 122,  44,  32,  48, 
+     41,  32,  42,  32, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  41,  32, 
+     43,  32,  40, 102, 108, 111, 
+     97, 116,  52,  40, 115, 112, 
+    101,  99, 117, 108,  97, 114, 
+     76, 105, 103, 104, 116,  46, 
+    120,  44,  32, 115, 112, 101, 
+     99, 117, 108,  97, 114,  76, 
+    105, 103, 104, 116,  46, 121, 
+     44,  32, 115, 112, 101,  99, 
+    117, 108,  97, 114,  76, 105, 
+    103, 104, 116,  46, 122,  44, 
+     32,  48,  41,  32,  42,  32, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  70,  97,  99, 116, 
+    111, 114,  41,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+    116, 101, 120, 116, 117, 114, 
+    101,  67, 111, 108, 111, 114, 
+     46,  97,  32,  61,  32, 109, 
      97, 116, 101, 114, 105,  97, 
     108,  67, 111, 108, 111, 114, 
-     32,  42,  32,  40,  49,  32, 
-     45,  32, 101, 102, 102, 101, 
-     99, 116,  67, 111, 108, 111, 
-    114,  46,  97,  32,  42,  32, 
-     97, 108, 112, 104,  97,  77, 
-    117, 108, 116, 105, 112, 108, 
-    105, 101, 114,  41,  59,  13, 
+     46,  97,  59,  13,  10,  32, 
+     32,  32,  32, 105, 102,  40, 
+     32, 105, 115, 110,  97, 110, 
+     40,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  46, 120,  32,  42, 
+     32, 100, 105, 102, 102, 117, 
+    115,  70,  97,  99, 116, 111, 
+    114,  32,  41,  32,  41,  13, 
      10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 125,  13,  10, 
-     32,  32,  32,  32, 125,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  52,  32, 
-    116, 101, 120, 116, 117, 114, 
-    101,  67, 111, 108, 111, 114, 
-     32,  61,  32, 115,  97, 116, 
-    117, 114,  97, 116, 101,  40, 
-     32,  40, 109,  97, 116, 101, 
-    114, 105,  97, 108,  67, 111, 
-    108, 111, 114,  32,  42,  32, 
-     97, 109,  98, 105, 101, 110, 
-    116,  70,  97,  99, 116, 111, 
-    114,  41,  32,  43,  32,  40, 
+     32,  32,  32, 116, 101, 120, 
+    116, 117, 114, 101,  67, 111, 
+    108, 111, 114,  32,  61,  32, 
+    109,  97, 116, 101, 114, 105, 
+     97, 108,  67, 111, 108, 111, 
+    114,  59,  13,  10,  32,  32, 
+     32,  32, 114, 101, 116, 117, 
+    114, 110,  32, 116, 101, 120, 
+    116, 117, 114, 101,  67, 111, 
+    108, 111, 114,  59,  13,  10, 
+     32,  32,  32,  32,  47,  47, 
+    114, 101, 116, 117, 114, 110, 
+     32, 116, 101, 120, 116, 117, 
+    114, 101,  67, 111, 108, 111, 
+    114,  59,  13,  10,  32,  32, 
+     32,  32,  47,  47, 105, 102, 
+     32,  40, 100, 105, 102, 102, 
+    117, 115,  70,  97,  99, 116, 
+    111, 114,  32,  61,  61,  32, 
+     48,  41,  13,  10,  32,  32, 
+     32,  32,  47,  47,   9, 114, 
+    101, 116, 117, 114, 110,  32, 
     102, 108, 111,  97, 116,  52, 
+     40,  49,  44,  32,  49,  44, 
+     32,  48,  44,  32,  49,  41, 
+     59,  13,  10,  32,  32,  32, 
+     32,  47,  42, 105, 102,  32, 
+     40, 105, 115, 110,  97, 110, 
      40, 100, 105, 102, 102, 117, 
     115, 101,  76, 105, 103, 104, 
-    116,  46, 120,  44,  32, 100, 
+    116,  46, 120,  41,  32, 124, 
+    124,  32, 105, 115, 110,  97, 
+    110,  40, 100, 105, 102, 102, 
+    117, 115,  70,  97,  99, 116, 
+    111, 114,  41,  32, 124, 124, 
+     32, 105, 115, 105, 110, 102, 
+     40, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  46, 120,  41,  32, 124, 
+    124,  32, 105, 115, 105, 110, 
+    102,  40,  45, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  46, 120,  41, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 114, 
+    101, 116, 117, 114, 110,  32, 
+    102, 108, 111,  97, 116,  52, 
+     40,  48,  44,  32,  49,  44, 
+     32,  49,  44,  32,  49,  41, 
+     59,  13,  10,  32,  32,  32, 
+     32, 105, 102,  32,  40, 105, 
+    115, 110,  97, 110,  40, 100, 
     105, 102, 102, 117, 115, 101, 
      76, 105, 103, 104, 116,  46, 
-    121,  44,  32, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 122,  44, 
-     32,  48,  41,  32,  42,  32, 
-    100, 105, 102, 102, 117, 115, 
-     70,  97,  99, 116, 111, 114, 
-     41,  32,  43,  32,  40, 102, 
-    108, 111,  97, 116,  52,  40, 
-    115, 112, 101,  99, 117, 108, 
-     97, 114,  76, 105, 103, 104, 
-    116,  46, 120,  44,  32, 115, 
-    112, 101,  99, 117, 108,  97, 
-    114,  76, 105, 103, 104, 116, 
-     46, 121,  44,  32, 115, 112, 
-    101,  99, 117, 108,  97, 114, 
-     76, 105, 103, 104, 116,  46, 
-    122,  44,  32,  48,  41,  32, 
-     42,  32, 115, 112, 101,  99, 
-    117, 108,  97, 114,  70,  97, 
-     99, 116, 111, 114,  41,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32, 116, 101, 120, 116, 
-    117, 114, 101,  67, 111, 108, 
-    111, 114,  46,  97,  32,  61, 
-     32, 109,  97, 116, 101, 114, 
-    105,  97, 108,  67, 111, 108, 
-    111, 114,  46,  97,  59,  13, 
-     10,  32,  32,  32,  32, 105, 
-    102,  40,  32, 105, 115, 110, 
-     97, 110,  40,  32, 100, 105, 
+    120,  32,  45,  32, 100, 105, 
     102, 102, 117, 115, 101,  76, 
     105, 103, 104, 116,  46, 120, 
-     32,  42,  32, 100, 105, 102, 
-    102, 117, 115,  70,  97,  99, 
-    116, 111, 114,  32,  41,  32, 
-     41,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 116, 
-    101, 120, 116, 117, 114, 101, 
-     67, 111, 108, 111, 114,  32, 
-     61,  32, 109,  97, 116, 101, 
-    114, 105,  97, 108,  67, 111, 
-    108, 111, 114,  59,  13,  10, 
-     32,  32,  32,  32, 114, 101, 
-    116, 117, 114, 110,  32, 116, 
-    101, 120, 116, 117, 114, 101, 
-     67, 111, 108, 111, 114,  59, 
-     13,  10,  32,  32,  32,  32, 
-     47,  47, 114, 101, 116, 117, 
-    114, 110,  32, 116, 101, 120, 
-    116, 117, 114, 101,  67, 111, 
-    108, 111, 114,  59,  13,  10, 
-     32,  32,  32,  32,  47,  47, 
-    105, 102,  32,  40, 100, 105, 
-    102, 102, 117, 115,  70,  97, 
-     99, 116, 111, 114,  32,  61, 
-     61,  32,  48,  41,  13,  10, 
-     32,  32,  32,  32,  47,  47, 
-      9, 114, 101, 116, 117, 114, 
-    110,  32, 102, 108, 111,  97, 
-    116,  52,  40,  49,  44,  32, 
-     49,  44,  32,  48,  44,  32, 
-     49,  41,  59,  13,  10,  32, 
-     32,  32,  32,  47,  42, 105, 
-    102,  32,  40, 105, 115, 110, 
-     97, 110,  40, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  41, 
-     32, 124, 124,  32, 105, 115, 
-    110,  97, 110,  40, 100, 105, 
-    102, 102, 117, 115,  70,  97, 
-     99, 116, 111, 114,  41,  32, 
-    124, 124,  32, 105, 115, 105, 
-    110, 102,  40, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  41, 
-     32, 124, 124,  32, 105, 115, 
-    105, 110, 102,  40,  45, 100, 
+     41,  32,  38,  38,  32, 105, 
+    115, 110,  97, 110,  40, 100, 
     105, 102, 102, 117, 115, 101, 
      76, 105, 103, 104, 116,  46, 
-    120,  41,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32, 114, 101, 116, 117, 114, 
-    110,  32, 102, 108, 111,  97, 
-    116,  52,  40,  48,  44,  32, 
-     49,  44,  32,  49,  44,  32, 
-     49,  41,  59,  13,  10,  32, 
-     32,  32,  32, 105, 102,  32, 
-     40, 105, 115, 110,  97, 110, 
-     40, 100, 105, 102, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
-    116,  46, 120,  32,  45,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     46, 120,  41,  32,  38,  38, 
-     32, 105, 115, 110,  97, 110, 
-     40, 100, 105, 102, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
-    116,  46, 120,  32,  42,  32, 
-    100, 105, 102, 102, 117, 115, 
-     70,  97,  99, 116, 111, 114, 
-     41,  32,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32, 114, 101, 116, 117, 114, 
-    110,  32, 102, 108, 111,  97, 
-    116,  52,  40,  49,  44,  32, 
-     49,  44,  32,  49,  44,  32, 
-     49,  41,  59,  13,  10,  32, 
-     32,  32,  32, 105, 102,  32, 
-     40,  40, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  46, 120,  32,  42, 
-     32, 100, 105, 102, 102, 117, 
-    115,  70,  97,  99, 116, 111, 
-    114,  41,  32,  33,  61,  32, 
-     48,  32,  38,  38,  32,  40, 
+    120,  32,  42,  32, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  41,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 114, 
+    101, 116, 117, 114, 110,  32, 
+    102, 108, 111,  97, 116,  52, 
+     40,  49,  44,  32,  49,  44, 
+     32,  49,  44,  32,  49,  41, 
+     59,  13,  10,  32,  32,  32, 
+     32, 105, 102,  32,  40,  40, 
     100, 105, 102, 102, 117, 115, 
     101,  76, 105, 103, 104, 116, 
      46, 120,  32,  42,  32, 100, 
     105, 102, 102, 117, 115,  70, 
      97,  99, 116, 111, 114,  41, 
-     32,  33,  61,  32,  45,  48, 
-     41,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 114, 
+     32,  33,  61,  32,  48,  32, 
+     38,  38,  32,  40, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116,  46, 120, 
+     32,  42,  32, 100, 105, 102, 
+    102, 117, 115,  70,  97,  99, 
+    116, 111, 114,  41,  32,  33, 
+     61,  32,  45,  48,  41,  13, 
+     10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 114, 101, 116, 
+    117, 114, 110,  32, 102, 108, 
+    111,  97, 116,  52,  40,  48, 
+     44,  32,  48,  44,  32,  49, 
+     44,  32,  49,  41,  59,  13, 
+     10,  32,  32,  32,  32, 114, 
     101, 116, 117, 114, 110,  32, 
     102, 108, 111,  97, 116,  52, 
-     40,  48,  44,  32,  48,  44, 
-     32,  49,  44,  32,  49,  41, 
-     59,  13,  10,  32,  32,  32, 
-     32, 114, 101, 116, 117, 114, 
-    110,  32, 102, 108, 111,  97, 
-    116,  52,  40,  48,  44,  32, 
-     49,  44,  32,  48,  44,  32, 
-     49,  41,  59,  42,  47,  13, 
-     10, 125,   0,   0,   0,   0, 
+     40,  48,  44,  32,  49,  44, 
+     32,  48,  44,  32,  49,  41, 
+     59,  42,  47,  13,  10, 125, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2999,39 +2913,40 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 254, 239, 254, 239, 
-      1,   0,   0,   0,  71,  19, 
-      0,   0,   0,  67,  58,  92, 
-     85, 115, 101, 114, 115,  92, 
-    107, 111, 108, 106,  97,  92, 
-     68, 101, 115, 107, 116, 111, 
-    112,  92,  75, 111, 108, 106, 
-     97,  45,  83, 116, 114, 111, 
-    104, 109,  45,  71,  97, 109, 
-    101, 115,  92,  65, 108, 108, 
-    103, 101, 109, 101, 105, 110, 
-     92,  70, 114,  97, 109, 101, 
-    119, 111, 114, 107,  92,  68, 
-     88,  49,  49,  80, 105, 120, 
-    101, 108,  83, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0,   0,  99,  58,  92, 
-    117, 115, 101, 114, 115,  92, 
-    107, 111, 108, 106,  97,  92, 
-    100, 101, 115, 107, 116, 111, 
-    112,  92, 107, 111, 108, 106, 
-     97,  45, 115, 116, 114, 111, 
-    104, 109,  45, 103,  97, 109, 
-    101, 115,  92,  97, 108, 108, 
-    103, 101, 109, 101, 105, 110, 
-     92, 102, 114,  97, 109, 101, 
-    119, 111, 114, 107,  92, 100, 
-    120,  49,  49, 112, 105, 120, 
-    101, 108, 115, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0,  47,  47,  47,  47, 
+      0,   0,   0,   0,   0,   0, 
+    254, 239, 254, 239,   1,   0, 
+      0,   0,  71,  19,   0,   0, 
+      0,  67,  58,  92,  85, 115, 
+    101, 114, 115,  92, 107, 111, 
+    108, 106,  97,  92,  68, 101, 
+    115, 107, 116, 111, 112,  92, 
+     75, 111, 108, 106,  97,  45, 
+     83, 116, 114, 111, 104, 109, 
+     45,  71,  97, 109, 101, 115, 
+     92,  65, 108, 108, 103, 101, 
+    109, 101, 105, 110,  92,  70, 
+    114,  97, 109, 101, 119, 111, 
+    114, 107,  92,  68,  88,  49, 
+     49,  80, 105, 120, 101, 108, 
+     83, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
+      0,  99,  58,  92, 117, 115, 
+    101, 114, 115,  92, 107, 111, 
+    108, 106,  97,  92, 100, 101, 
+    115, 107, 116, 111, 112,  92, 
+    107, 111, 108, 106,  97,  45, 
+    115, 116, 114, 111, 104, 109, 
+     45, 103,  97, 109, 101, 115, 
+     92,  97, 108, 108, 103, 101, 
+    109, 101, 105, 110,  92, 102, 
+    114,  97, 109, 101, 119, 111, 
+    114, 107,  92, 100, 120,  49, 
+     49, 112, 105, 120, 101, 108, 
+    115, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  32,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -3046,10 +2961,9 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     47,  47,  32,  71,  76,  79, 
-     66,  65,  76,  83,  32,  47, 
-     47,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,  47,  47, 
+     32,  71,  76,  79,  66,  65, 
+     76,  83,  32,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -3064,10 +2978,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  32, 
      32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -3082,12 +2996,13 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  84, 101, 120, 116, 
-    117, 114, 101,  50,  68,  32, 
-    115, 104,  97, 100,  27, 226, 
-     48,   1, 128,   0,   0,   0, 
-      5, 184, 178, 234, 188, 227, 
-    219,   1,   1,   0,   0,   0, 
+     32,  32,  32,  32,  13,  10, 
+     84, 101, 120, 116, 117, 114, 
+    101,  50,  68,  32, 115, 104, 
+     97, 100,  27, 226,  48,   1, 
+    128,   0,   0,   0, 188, 175, 
+    117,  59, 166,  22, 220,   1, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3095,15 +3010,15 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   2,   0, 
       0,   0,   1,   0,   0,   0, 
-      2,   0,   0,   0,   1,   0, 
-      0,   0,   2,   0,   0,   0, 
-      0,   0,   0,   0,  85,   0, 
-      0,   0,  40,   0,   0,   0, 
-     27, 226,  48,   1,  49,  69, 
-     77,  40, 158,  18,   0,   0, 
-      1,   0,   0,   0,  84,   0, 
+      2,   0,   0,   0,   0,   0, 
       0,   0,  85,   0,   0,   0, 
+     40,   0,   0,   0,  27, 226, 
+     48,   1,  49,  69,  77,  40, 
+    158,  18,   0,   0,   1,   0, 
+      0,   0,  84,   0,   0,   0, 
+     85,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3169,209 +3084,224 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      4,   0,   0,   0,  66,   0, 
-     60,  17,  16,   1,   0,   0, 
-      0,   1,  10,   0,   1,   0, 
-     76,  15, 244, 101,  10,   0, 
-      1,   0,  76,  15, 244, 101, 
-     77, 105,  99, 114, 111, 115, 
-    111, 102, 116,  32,  40,  82, 
-     41,  32,  72,  76,  83,  76, 
-     32,  83, 104,  97, 100, 101, 
-    114,  32,  67, 111, 109, 112, 
-    105, 108, 101, 114,  32,  49, 
-     48,  46,  49,   0,   0,   0, 
-     66,   0,  61,  17,   1, 104, 
-    108, 115, 108,  70, 108,  97, 
-    103, 115,   0,  48, 120,  53, 
-      0, 104, 108, 115, 108,  84, 
-     97, 114, 103, 101, 116,   0, 
-    112, 115,  95,  53,  95,  48, 
-      0, 104, 108, 115, 108,  69, 
-    110, 116, 114, 121,   0,  84, 
-    101, 120, 116, 117, 114, 101, 
-     80, 105, 120, 101, 108,  83, 
-    104,  97, 100, 101, 114,   0, 
-      0,   0,  58,   0,  16,  17, 
-      0,   0,   0,   0, 200,   8, 
-      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   4,   0, 
+      0,   0,  66,   0,  60,  17, 
+     16,   1,   0,   0,   0,   1, 
+     10,   0,   1,   0,  46,  18, 
+    244, 101,  10,   0,   1,   0, 
+     46,  18, 244, 101,  77, 105, 
+     99, 114, 111, 115, 111, 102, 
+    116,  32,  40,  82,  41,  32, 
+     72,  76,  83,  76,  32,  83, 
+    104,  97, 100, 101, 114,  32, 
+     67, 111, 109, 112, 105, 108, 
+    101, 114,  32,  49,  48,  46, 
+     49,   0,   0,   0,  66,   0, 
+     61,  17,   1, 104, 108, 115, 
+    108,  70, 108,  97, 103, 115, 
+      0,  48, 120,  53,   0, 104, 
+    108, 115, 108,  84,  97, 114, 
+    103, 101, 116,   0, 112, 115, 
+     95,  53,  95,  48,   0, 104, 
+    108, 115, 108,  69, 110, 116, 
+    114, 121,   0,  84, 101, 120, 
+    116, 117, 114, 101,  80, 105, 
+    120, 101, 108,  83, 104,  97, 
+    100, 101, 114,   0,   0,   0, 
+     58,   0,  16,  17,   0,   0, 
+      0,   0, 200,   8,   0,   0, 
+      0,   0,   0,   0,  64,  15, 
+      0,   0,   0,   0,   0,   0, 
+     64,  15,   0,   0,   7,  16, 
+      0,   0, 208,   0,   0,   0, 
+      1,   0, 160,  84, 101, 120, 
+    116, 117, 114, 101,  80, 105, 
+    120, 101, 108,  83, 104,  97, 
+    100, 101, 114,   0,   0,   0, 
+     46,   0,  62,  17,   4,  16, 
+      0,   0,   9,   0, 105, 110, 
+    112, 117, 116,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,   0,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
      64,  15,   0,   0,   0,   0, 
-      0,   0,  64,  15,   0,   0, 
-      7,  16,   0,   0, 208,   0, 
-      0,   0,   1,   0, 160,  84, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,   4,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,   4,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,   8,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,   8,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  12,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  12,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  16,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  16,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  20,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  20,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  24,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  24,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  28,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  28,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  32,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  32,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  36,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  36,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  40,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  48,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  44,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  52,   0,   0,   0, 
+     22,   0,  80,  17,   1,   0, 
+      5,   0,  48,   0,   4,   0, 
+    208,   0,   0,   0,   1,   0, 
+     64,  15,  56,   0,   0,   0, 
+     74,   0,  62,  17,   6,  16, 
+      0,   0, 136,   0,  60,  84, 
     101, 120, 116, 117, 114, 101, 
      80, 105, 120, 101, 108,  83, 
-    104,  97, 100, 101, 114,   0, 
-      0,   0,  46,   0,  62,  17, 
-      4,  16,   0,   0,   9,   0, 
-    105, 110, 112, 117, 116,   0, 
+    104,  97, 100, 101, 114,  32, 
+    114, 101, 116, 117, 114, 110, 
+     32, 118,  97, 108, 117, 101, 
+     62,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      0,   0,   4,   0, 208,   0, 
+      0,   0,   1,   0,  64,  15, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      4,   0,   4,   0, 208,   0, 
+      0,   0,   1,   0,  64,  15, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+      8,   0,   4,   0, 208,   0, 
+      0,   0,   1,   0,  64,  15, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   2,   0,   5,   0, 
+     12,   0,   4,   0, 208,   0, 
+      0,   0,   1,   0,  64,  15, 
+     12,   0,   0,   0,  50,   0, 
+     62,  17,   2,  16,   0,   0, 
+      8,   0, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,   0,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,   0,   0, 
-      0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,   4,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,   4,   0, 
-      0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,   8,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,   8,   0, 
-      0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  12,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  12,   0, 
-      0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  16,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  16,   0, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0, 240,   0,   0,   0, 
+      1,   0,  72,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  20,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  20,   0, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0, 240,   0,   0,   0, 
+      1,   0,  72,   0,   4,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  24,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  24,   0, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0, 240,   0,   0,   0, 
+      1,   0,  72,   0,   8,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  28,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  28,   0, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0,  56,   1,   0,   0, 
+      1,   0,  64,   3,  32,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  32,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  32,   0, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0,  56,   1,   0,   0, 
+      1,   0,  44,   3,  36,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  36,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  36,   0, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0,  56,   1,   0,   0, 
+      1,   0,  44,   3,  40,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  40,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  48,   0, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0, 100,   4,   0,   0, 
+      1,   0, 100,  10,  52,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  44,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  52,   0, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0, 100,   4,   0,   0, 
+      1,   0, 100,  10,  56,   0, 
       0,   0,  22,   0,  80,  17, 
-      1,   0,   5,   0,  48,   0, 
-      4,   0, 208,   0,   0,   0, 
-      1,   0,  64,  15,  56,   0, 
-      0,   0,  74,   0,  62,  17, 
-      6,  16,   0,   0, 136,   0, 
-     60,  84, 101, 120, 116, 117, 
-    114, 101,  80, 105, 120, 101, 
-    108,  83, 104,  97, 100, 101, 
-    114,  32, 114, 101, 116, 117, 
-    114, 110,  32, 118,  97, 108, 
-    117, 101,  62,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   0,   0,   4,   0, 
-    208,   0,   0,   0,   1,   0, 
-     64,  15,   0,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   4,   0,   4,   0, 
-    208,   0,   0,   0,   1,   0, 
-     64,  15,   4,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,   8,   0,   4,   0, 
-    208,   0,   0,   0,   1,   0, 
-     64,  15,   8,   0,   0,   0, 
-     22,   0,  80,  17,   2,   0, 
-      5,   0,  12,   0,   4,   0, 
-    208,   0,   0,   0,   1,   0, 
-     64,  15,  12,   0,   0,   0, 
-     50,   0,  62,  17,   2,  16, 
-      0,   0,   8,   0, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,   0,   0, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0, 120,   4,   0,   0, 
+      1,   0, 152,  11,  48,   0, 
+      0,   0,  54,   0,  62,  17, 
+      2,  16,   0,   0,   8,   0, 
+    115, 112, 101,  99, 117, 108, 
+     97, 114,  76, 105, 103, 104, 
+    116,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 240,   0, 
-      0,   0,   1,   0,  72,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0, 240,   0, 
-      0,   0,   1,   0,  72,   0, 
-      4,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0, 240,   0, 
-      0,   0,   1,   0,  72,   0, 
-      8,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0,  56,   1, 
+      0,   0,   4,   0,  16,   1, 
       0,   0,   1,   0,  64,   3, 
-     32,   0,   0,   0,  22,   0, 
+     16,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0,  56,   1, 
-      0,   0,   1,   0,  44,   3, 
-     36,   0,   0,   0,  22,   0, 
+      4,   0,   4,   0,  16,   1, 
+      0,   0,   1,   0,  64,   3, 
+     20,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0,  56,   1, 
-      0,   0,   1,   0,  44,   3, 
-     40,   0,   0,   0,  22,   0, 
+      8,   0,   4,   0,  16,   1, 
+      0,   0,   1,   0,  64,   3, 
+     24,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0, 100,   4, 
-      0,   0,   1,   0, 100,  10, 
-     52,   0,   0,   0,  22,   0, 
+      0,   0,   4,   0,  80,   4, 
+      0,   0,   1,   0, 180,  10, 
+      4,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0, 100,   4, 
-      0,   0,   1,   0, 100,  10, 
-     56,   0,   0,   0,  22,   0, 
+      4,   0,   4,   0,  80,   4, 
+      0,   0,   1,   0, 180,  10, 
+      8,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 120,   4, 
-      0,   0,   1,   0, 152,  11, 
-     48,   0,   0,   0,  54,   0, 
-     62,  17,   2,  16,   0,   0, 
-      8,   0, 115, 112, 101,  99, 
-    117, 108,  97, 114,  76, 105, 
-    103, 104, 116,   0,   0,   0, 
+      8,   0,   4,   0,  80,   4, 
+      0,   0,   1,   0,  84,  11, 
+     12,   0,   0,   0,  42,   0, 
+     62,  17, 116,   0,   0,   0, 
+      0,   0, 106,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-     16,   1,   0,   0,   1,   0, 
-     64,   3,  16,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-     16,   1,   0,   0,   1,   0, 
-     64,   3,  20,   0,   0,   0, 
+      1,   0,   0,   0,   4,   0, 
+     36,   1,   0,   0,   1,   0, 
+     40,   0,  12,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-     16,   1,   0,   0,   1,   0, 
-     64,   3,  24,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-     80,   4,   0,   0,   1,   0, 
-    180,  10,   4,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-     80,   4,   0,   0,   1,   0, 
-    180,  10,   8,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-     80,   4,   0,   0,   1,   0, 
-     84,  11,  12,   0,   0,   0, 
+      1,   0,   0,   0,   4,   0, 
+     76,   1,   0,   0,   1,   0, 
+     64,   3,  28,   0,   0,   0, 
      42,   0,  62,  17, 116,   0, 
-      0,   0,   0,   0, 106,   0, 
+      0,   0,   0,   0, 105,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3379,808 +3309,792 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
       0,   0,   1,   0,   0,   0, 
-      4,   0,  36,   1,   0,   0, 
-      1,   0,  40,   0,  12,   0, 
+      4,   0,  60,   4,   0,   0, 
+      1,   0,  80,   0,   0,   0, 
       0,   0,  22,   0,  80,  17, 
       0,   0,   1,   0,   0,   0, 
-      4,   0,  76,   1,   0,   0, 
-      1,   0,  64,   3,  28,   0, 
-      0,   0,  42,   0,  62,  17, 
-    116,   0,   0,   0,   0,   0, 
-    105,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   1,   0, 
-      0,   0,   4,   0,  60,   4, 
-      0,   0,   1,   0,  80,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   1,   0, 
-      0,   0,   4,   0, 140,   4, 
-      0,   0,   1,   0, 164,   6, 
-     28,   0,   0,   0,  46,   0, 
-     62,  17,   2,  16,   0,   0, 
-      8,   0, 108, 105, 103, 104, 
-    116,  68, 105, 114,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+      4,   0, 140,   4,   0,   0, 
+      1,   0, 164,   6,  28,   0, 
+      0,   0,  46,   0,  62,  17, 
+      2,  16,   0,   0,   8,   0, 
+    108, 105, 103, 104, 116,  68, 
+    105, 114,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 116,   5, 
-      0,   0,   1,   0, 148,   2, 
-     64,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0, 116,   5, 
-      0,   0,   1,   0, 148,   2, 
-     68,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0, 116,   5, 
-      0,   0,   1,   0, 148,   2, 
-     72,   0,   0,   0,  46,   0, 
-     62,  17,  64,   0,   0,   0, 
-      0,   0, 102,  97,  99, 116, 
-    111, 114,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0, 116,   5,   0,   0, 
+      1,   0, 148,   2,  64,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0, 116,   5,   0,   0, 
+      1,   0, 148,   2,  68,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0, 116,   5,   0,   0, 
+      1,   0, 148,   2,  72,   0, 
+      0,   0,  46,   0,  62,  17, 
+     64,   0,   0,   0,   0,   0, 
+    102,  97,  99, 116, 111, 114, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     80,  17,   0,   0,   1,   0, 
-      0,   0,   4,   0, 244,   5, 
-      0,   0,   1,   0,  16,   5, 
-      4,   0, 120,   0,  44,   0, 
-      0,   0,  42,   0,  62,  17, 
-     64,   0,   0,   0,   0,   0, 
-    102,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,  26,   0,  80,  17, 
+      0,   0,   1,   0,   0,   0, 
+      4,   0, 244,   5,   0,   0, 
+      1,   0,  16,   5,   4,   0, 
+    120,   0,  44,   0,   0,   0, 
+     42,   0,  62,  17,  64,   0, 
+      0,   0,   0,   0, 102,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  26,   0, 
-     80,  17,   0,   0,   1,   0, 
-      0,   0,   4,   0, 220,   6, 
-      0,   0,   1,   0,  40,   4, 
-     72,   1, 164,   1,  60,   0, 
-      0,   0,  54,   0,  62,  17, 
-      0,  16,   0,   0,   8,   0, 
-    109,  97, 116, 101, 114, 105, 
-     97, 108,  67, 111, 108, 111, 
-    114,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0,  48,  11, 
-      0,   0,   1,   0, 224,   4, 
-     16,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0,  48,  11, 
-      0,   0,   1,   0, 224,   4, 
-     20,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0,  48,  11, 
-      0,   0,   1,   0, 224,   4, 
-     24,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     12,   0,   4,   0,  48,  11, 
-      0,   0,   1,   0, 224,   4, 
-     28,   0,   0,   0,  42,   0, 
-     62,  17,  64,   0,   0,   0, 
-      0,   0, 100, 105, 115, 116, 
+      0,   0,  26,   0,  80,  17, 
+      0,   0,   1,   0,   0,   0, 
+      4,   0, 220,   6,   0,   0, 
+      1,   0,  40,   4,  72,   1, 
+    164,   1,  60,   0,   0,   0, 
+     54,   0,  62,  17,   0,  16, 
+      0,   0,   8,   0, 109,  97, 
+    116, 101, 114, 105,  97, 108, 
+     67, 111, 108, 111, 114,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      1,   0,   0,   0,   4,   0, 
-    172,  12,   0,   0,   1,   0, 
-     68,   0,   0,   0,   0,   0, 
-     54,   0,  62,  17,  64,   0, 
-      0,   0,   0,   0,  97, 108, 
-    112, 104,  97,  77, 117, 108, 
-    116, 105, 112, 108, 105, 101, 
-    114,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0,  48,  11,   0,   0, 
+      1,   0, 224,   4,  16,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0,  48,  11,   0,   0, 
+      1,   0, 224,   4,  20,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0,  48,  11,   0,   0, 
+      1,   0, 224,   4,  24,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  12,   0, 
+      4,   0,  48,  11,   0,   0, 
+      1,   0, 224,   4,  28,   0, 
+      0,   0,  42,   0,  62,  17, 
+     64,   0,   0,   0,   0,   0, 
+    100, 105, 115, 116,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  22,   0,  80,  17, 
-      0,   0,   1,   0,   0,   0, 
-      4,   0,  44,  13,   0,   0, 
-      1,   0, 232,   0,   0,   0, 
-      0,   0,  50,   0,  62,  17, 
-      0,  16,   0,   0,   8,   0, 
-    101, 102, 102, 101,  99, 116, 
-     67, 111, 108, 111, 114,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   0,   0,   1,   0, 
+      0,   0,   4,   0, 172,  12, 
+      0,   0,   1,   0,  68,   0, 
+      0,   0,   0,   0,  54,   0, 
+     62,  17,  64,   0,   0,   0, 
+      0,   0,  97, 108, 112, 104, 
+     97,  77, 117, 108, 116, 105, 
+    112, 108, 105, 101, 114,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
      22,   0,  80,  17,   0,   0, 
-      5,   0,   0,   0,   4,   0, 
-    172,  13,   0,   0,   1,   0, 
-     76,   0,  32,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   4,   0,   4,   0, 
-    172,  13,   0,   0,   1,   0, 
-    184,   0,  36,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,   8,   0,   4,   0, 
-    172,  13,   0,   0,   1,   0, 
-    184,   0,  40,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  12,   0,   4,   0, 
-    172,  13,   0,   0,   1,   0, 
-    184,   0,  44,   0,   0,   0, 
+      1,   0,   0,   0,   4,   0, 
+     44,  13,   0,   0,   1,   0, 
+    232,   0,   0,   0,   0,   0, 
      50,   0,  62,  17,   0,  16, 
-      0,   0,   8,   0, 116, 101, 
-    120, 116, 117, 114, 101,  67, 
-    111, 108, 111, 114,   0,   0, 
+      0,   0,   8,   0, 101, 102, 
+    102, 101,  99, 116,  67, 111, 
+    108, 111, 114,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 112,  15, 
-      0,   0,   1,   0, 160,   0, 
-      0,   0,   0,   0,  22,   0, 
+      0,   0,   4,   0, 172,  13, 
+      0,   0,   1,   0,  76,   0, 
+     32,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0, 112,  15, 
-      0,   0,   1,   0, 160,   0, 
-      4,   0,   0,   0,  22,   0, 
+      4,   0,   4,   0, 172,  13, 
+      0,   0,   1,   0, 184,   0, 
+     36,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0, 112,  15, 
-      0,   0,   1,   0, 160,   0, 
-      8,   0,   0,   0,  22,   0, 
+      8,   0,   4,   0, 172,  13, 
+      0,   0,   1,   0, 184,   0, 
+     40,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-     12,   0,   4,   0, 132,  15, 
-      0,   0,   1,   0, 140,   0, 
-     28,   0,   0,   0,   2,   0, 
-      6,   0, 244,   0,   0,   0, 
-     24,   0,   0,   0,   1,   0, 
-      0,   0,  16,   1, 244,  31, 
-     62, 245,  21, 224,  84, 221, 
-     19,  94, 228, 135, 110, 169, 
-    237, 238,   0,   0, 242,   0, 
-      0,   0, 112,  14,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      1,   0,  16,  16,   0,   0, 
-      0,   0,   0,   0,  50,   1, 
-      0,   0, 100,  14,   0,   0, 
+     12,   0,   4,   0, 172,  13, 
+      0,   0,   1,   0, 184,   0, 
+     44,   0,   0,   0,  50,   0, 
+     62,  17,   0,  16,   0,   0, 
+      8,   0, 116, 101, 120, 116, 
+    117, 114, 101,  67, 111, 108, 
+    111, 114,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0, 112,  15,   0,   0, 
+      1,   0, 160,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0, 112,  15,   0,   0, 
+      1,   0, 160,   0,   4,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0, 112,  15,   0,   0, 
+      1,   0, 160,   0,   8,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  12,   0, 
+      4,   0, 132,  15,   0,   0, 
+      1,   0, 140,   0,  28,   0, 
+      0,   0,   2,   0,   6,   0, 
+    244,   0,   0,   0,  24,   0, 
+      0,   0,   1,   0,   0,   0, 
+     16,   1, 244,  31,  62, 245, 
+     21, 224,  84, 221,  19,  94, 
+    228, 135, 110, 169, 237, 238, 
+      0,   0, 242,   0,   0,   0, 
+    112,  14,   0,   0,   0,   0, 
+      0,   0,   1,   0,   1,   0, 
+     16,  16,   0,   0,   0,   0, 
+      0,   0,  50,   1,   0,   0, 
+    100,  14,   0,   0, 208,   0, 
+      0,   0,  67,   0,   0, 128, 
     208,   0,   0,   0,  67,   0, 
-      0, 128, 208,   0,   0,   0, 
-     67,   0,   0,   0, 240,   0, 
-      0,   0,  68,   0,   0, 128, 
-    240,   0,   0,   0,  68,   0, 
-      0,   0,  16,   1,   0,   0, 
-     69,   0,   0, 128,  16,   1, 
-      0,   0,  69,   0,   0,   0, 
-     36,   1,   0,   0,  69,   0, 
-      0, 128,  36,   1,   0,   0, 
-     69,   0,   0,   0,  56,   1, 
+      0,   0, 240,   0,   0,   0, 
+     68,   0,   0, 128, 240,   0, 
+      0,   0,  68,   0,   0,   0, 
+     16,   1,   0,   0,  69,   0, 
+      0, 128,  16,   1,   0,   0, 
+     69,   0,   0,   0,  36,   1, 
       0,   0,  69,   0,   0, 128, 
-     56,   1,   0,   0,  69,   0, 
-      0,   0,  76,   1,   0,   0, 
-     69,   0,   0, 128,  76,   1, 
+     36,   1,   0,   0,  69,   0, 
+      0,   0,  56,   1,   0,   0, 
+     69,   0,   0, 128,  56,   1, 
       0,   0,  69,   0,   0,   0, 
-     80,   1,   0,   0,  69,   0, 
-      0, 128,  80,   1,   0,   0, 
-     69,   0,   0,   0, 112,   1, 
+     76,   1,   0,   0,  69,   0, 
+      0, 128,  76,   1,   0,   0, 
+     69,   0,   0,   0,  80,   1, 
       0,   0,  69,   0,   0, 128, 
-    112,   1,   0,   0,  69,   0, 
-      0,   0, 124,   1,   0,   0, 
-     71,   0,   0, 128, 124,   1, 
-      0,   0,  71,   0,   0,   0, 
-    168,   1,   0,   0,  71,   0, 
-      0, 128, 168,   1,   0,   0, 
-     71,   0,   0,   0, 212,   1, 
+     80,   1,   0,   0,  69,   0, 
+      0,   0, 112,   1,   0,   0, 
+     69,   0,   0, 128, 112,   1, 
+      0,   0,  69,   0,   0,   0, 
+    124,   1,   0,   0,  71,   0, 
+      0, 128, 124,   1,   0,   0, 
+     71,   0,   0,   0, 168,   1, 
       0,   0,  71,   0,   0, 128, 
-    212,   1,   0,   0,  71,   0, 
-      0,   0,   0,   2,   0,   0, 
-     71,   0,   0, 128,   0,   2, 
+    168,   1,   0,   0,  71,   0, 
+      0,   0, 212,   1,   0,   0, 
+     71,   0,   0, 128, 212,   1, 
       0,   0,  71,   0,   0,   0, 
-     24,   2,   0,   0,  71,   0, 
-      0, 128,  24,   2,   0,   0, 
-     71,   0,   0,   0,  52,   2, 
+      0,   2,   0,   0,  71,   0, 
+      0, 128,   0,   2,   0,   0, 
+     71,   0,   0,   0,  24,   2, 
       0,   0,  71,   0,   0, 128, 
-     52,   2,   0,   0,  71,   0, 
-      0,   0,  72,   2,   0,   0, 
-     71,   0,   0, 128,  72,   2, 
+     24,   2,   0,   0,  71,   0, 
+      0,   0,  52,   2,   0,   0, 
+     71,   0,   0, 128,  52,   2, 
       0,   0,  71,   0,   0,   0, 
+     72,   2,   0,   0,  71,   0, 
+      0, 128,  72,   2,   0,   0, 
+     71,   0,   0,   0, 100,   2, 
+      0,   0,  71,   0,   0, 128, 
     100,   2,   0,   0,  71,   0, 
-      0, 128, 100,   2,   0,   0, 
-     71,   0,   0,   0, 112,   2, 
+      0,   0, 112,   2,   0,   0, 
+     72,   0,   0, 128, 112,   2, 
+      0,   0,  69,   0,   0,   0, 
+    140,   2,   0,   0,  72,   0, 
+      0, 128, 140,   2,   0,   0, 
+     72,   0,   0,   0, 144,   2, 
       0,   0,  72,   0,   0, 128, 
-    112,   2,   0,   0,  69,   0, 
-      0,   0, 140,   2,   0,   0, 
-     72,   0,   0, 128, 140,   2, 
-      0,   0,  72,   0,   0,   0, 
     144,   2,   0,   0,  72,   0, 
-      0, 128, 144,   2,   0,   0, 
-     72,   0,   0,   0, 148,   2, 
-      0,   0,  73,   0,   0, 128, 
-    148,   2,   0,   0,  73,   0, 
-      0,   0, 192,   2,   0,   0, 
-     73,   0,   0, 128, 192,   2, 
+      0,   0, 148,   2,   0,   0, 
+     73,   0,   0, 128, 148,   2, 
       0,   0,  73,   0,   0,   0, 
-    236,   2,   0,   0,  73,   0, 
-      0, 128, 236,   2,   0,   0, 
-     73,   0,   0,   0,  24,   3, 
+    192,   2,   0,   0,  73,   0, 
+      0, 128, 192,   2,   0,   0, 
+     73,   0,   0,   0, 236,   2, 
       0,   0,  73,   0,   0, 128, 
-     24,   3,   0,   0,  73,   0, 
-      0,   0,  68,   3,   0,   0, 
-     73,   0,   0, 128,  68,   3, 
+    236,   2,   0,   0,  73,   0, 
+      0,   0,  24,   3,   0,   0, 
+     73,   0,   0, 128,  24,   3, 
       0,   0,  73,   0,   0,   0, 
-    112,   3,   0,   0,  73,   0, 
-      0, 128, 112,   3,   0,   0, 
-     73,   0,   0,   0, 156,   3, 
+     68,   3,   0,   0,  73,   0, 
+      0, 128,  68,   3,   0,   0, 
+     73,   0,   0,   0, 112,   3, 
       0,   0,  73,   0,   0, 128, 
-    156,   3,   0,   0,  73,   0, 
-      0,   0, 180,   3,   0,   0, 
-     73,   0,   0, 128, 180,   3, 
+    112,   3,   0,   0,  73,   0, 
+      0,   0, 156,   3,   0,   0, 
+     73,   0,   0, 128, 156,   3, 
       0,   0,  73,   0,   0,   0, 
-    208,   3,   0,   0,  73,   0, 
-      0, 128, 208,   3,   0,   0, 
-     73,   0,   0,   0, 236,   3, 
+    180,   3,   0,   0,  73,   0, 
+      0, 128, 180,   3,   0,   0, 
+     73,   0,   0,   0, 208,   3, 
       0,   0,  73,   0,   0, 128, 
-    236,   3,   0,   0,  73,   0, 
-      0,   0,   8,   4,   0,   0, 
-     69,   0,   0, 128,   8,   4, 
-      0,   0,  69,   0,   0,   0, 
+    208,   3,   0,   0,  73,   0, 
+      0,   0, 236,   3,   0,   0, 
+     73,   0,   0, 128, 236,   3, 
+      0,   0,  73,   0,   0,   0, 
+      8,   4,   0,   0,  69,   0, 
+      0, 128,   8,   4,   0,   0, 
+     69,   0,   0,   0,  36,   4, 
+      0,   0,  74,   0,   0, 128, 
      36,   4,   0,   0,  74,   0, 
-      0, 128,  36,   4,   0,   0, 
-     74,   0,   0,   0,  40,   4, 
-      0,   0,  75,   0,   0, 128, 
-     40,   4,   0,   0,  75,   0, 
-      0,   0,  60,   4,   0,   0, 
-     75,   0,   0, 128,  60,   4, 
+      0,   0,  40,   4,   0,   0, 
+     75,   0,   0, 128,  40,   4, 
       0,   0,  75,   0,   0,   0, 
-     80,   4,   0,   0,  75,   0, 
-      0, 128,  80,   4,   0,   0, 
-     75,   0,   0,   0, 100,   4, 
+     60,   4,   0,   0,  75,   0, 
+      0, 128,  60,   4,   0,   0, 
+     75,   0,   0,   0,  80,   4, 
       0,   0,  75,   0,   0, 128, 
-    100,   4,   0,   0,  75,   0, 
-      0,   0, 120,   4,   0,   0, 
-     75,   0,   0, 128, 120,   4, 
+     80,   4,   0,   0,  75,   0, 
+      0,   0, 100,   4,   0,   0, 
+     75,   0,   0, 128, 100,   4, 
       0,   0,  75,   0,   0,   0, 
-    140,   4,   0,   0,  75,   0, 
-      0, 128, 140,   4,   0,   0, 
-     75,   0,   0,   0, 144,   4, 
+    120,   4,   0,   0,  75,   0, 
+      0, 128, 120,   4,   0,   0, 
+     75,   0,   0,   0, 140,   4, 
       0,   0,  75,   0,   0, 128, 
-    144,   4,   0,   0,  75,   0, 
-      0,   0, 176,   4,   0,   0, 
-     75,   0,   0, 128, 176,   4, 
+    140,   4,   0,   0,  75,   0, 
+      0,   0, 144,   4,   0,   0, 
+     75,   0,   0, 128, 144,   4, 
       0,   0,  75,   0,   0,   0, 
-    188,   4,   0,   0,  77,   0, 
-      0, 128, 188,   4,   0,   0, 
-     77,   0,   0,   0, 232,   4, 
+    176,   4,   0,   0,  75,   0, 
+      0, 128, 176,   4,   0,   0, 
+     75,   0,   0,   0, 188,   4, 
       0,   0,  77,   0,   0, 128, 
-    232,   4,   0,   0,  77,   0, 
-      0,   0,  20,   5,   0,   0, 
-     77,   0,   0, 128,  20,   5, 
+    188,   4,   0,   0,  77,   0, 
+      0,   0, 232,   4,   0,   0, 
+     77,   0,   0, 128, 232,   4, 
       0,   0,  77,   0,   0,   0, 
-     64,   5,   0,   0,  77,   0, 
-      0, 128,  64,   5,   0,   0, 
-     77,   0,   0,   0,  88,   5, 
+     20,   5,   0,   0,  77,   0, 
+      0, 128,  20,   5,   0,   0, 
+     77,   0,   0,   0,  64,   5, 
       0,   0,  77,   0,   0, 128, 
-     88,   5,   0,   0,  77,   0, 
-      0,   0, 116,   5,   0,   0, 
-     79,   0,   0, 128, 116,   5, 
-      0,   0,  79,   0,   0,   0, 
-    144,   5,   0,   0,  79,   0, 
-      0, 128, 144,   5,   0,   0, 
-     79,   0,   0,   0, 164,   5, 
+     64,   5,   0,   0,  77,   0, 
+      0,   0,  88,   5,   0,   0, 
+     77,   0,   0, 128,  88,   5, 
+      0,   0,  77,   0,   0,   0, 
+    116,   5,   0,   0,  79,   0, 
+      0, 128, 116,   5,   0,   0, 
+     79,   0,   0,   0, 144,   5, 
       0,   0,  79,   0,   0, 128, 
-    164,   5,   0,   0,  79,   0, 
-      0,   0, 184,   5,   0,   0, 
-     79,   0,   0, 128, 184,   5, 
+    144,   5,   0,   0,  79,   0, 
+      0,   0, 164,   5,   0,   0, 
+     79,   0,   0, 128, 164,   5, 
       0,   0,  79,   0,   0,   0, 
+    184,   5,   0,   0,  79,   0, 
+      0, 128, 184,   5,   0,   0, 
+     79,   0,   0,   0, 212,   5, 
+      0,   0,  79,   0,   0, 128, 
     212,   5,   0,   0,  79,   0, 
-      0, 128, 212,   5,   0,   0, 
-     79,   0,   0,   0, 224,   5, 
-      0,   0,  80,   0,   0, 128, 
-    224,   5,   0,   0,  80,   0, 
-      0,   0, 244,   5,   0,   0, 
-     80,   0,   0, 128, 244,   5, 
+      0,   0, 224,   5,   0,   0, 
+     80,   0,   0, 128, 224,   5, 
       0,   0,  80,   0,   0,   0, 
-    248,   5,   0,   0,  82,   0, 
-      0, 128, 248,   5,   0,   0, 
-     82,   0,   0,   0,  36,   6, 
+    244,   5,   0,   0,  80,   0, 
+      0, 128, 244,   5,   0,   0, 
+     80,   0,   0,   0, 248,   5, 
       0,   0,  82,   0,   0, 128, 
-     36,   6,   0,   0,  82,   0, 
-      0,   0,  64,   6,   0,   0, 
-     82,   0,   0, 128,  64,   6, 
+    248,   5,   0,   0,  82,   0, 
+      0,   0,  36,   6,   0,   0, 
+     82,   0,   0, 128,  36,   6, 
       0,   0,  82,   0,   0,   0, 
-     84,   6,   0,   0,  82,   0, 
-      0, 128,  84,   6,   0,   0, 
-     82,   0,   0,   0, 112,   6, 
+     64,   6,   0,   0,  82,   0, 
+      0, 128,  64,   6,   0,   0, 
+     82,   0,   0,   0,  84,   6, 
       0,   0,  82,   0,   0, 128, 
-    112,   6,   0,   0,  82,   0, 
-      0,   0, 116,   6,   0,   0, 
-     83,   0,   0, 128, 116,   6, 
-      0,   0,  83,   0,   0,   0, 
-    144,   6,   0,   0,  83,   0, 
-      0, 128, 144,   6,   0,   0, 
-     83,   0,   0,   0, 164,   6, 
+     84,   6,   0,   0,  82,   0, 
+      0,   0, 112,   6,   0,   0, 
+     82,   0,   0, 128, 112,   6, 
+      0,   0,  82,   0,   0,   0, 
+    116,   6,   0,   0,  83,   0, 
+      0, 128, 116,   6,   0,   0, 
+     83,   0,   0,   0, 144,   6, 
       0,   0,  83,   0,   0, 128, 
-    164,   6,   0,   0,  83,   0, 
-      0,   0, 192,   6,   0,   0, 
-     83,   0,   0, 128, 192,   6, 
+    144,   6,   0,   0,  83,   0, 
+      0,   0, 164,   6,   0,   0, 
+     83,   0,   0, 128, 164,   6, 
       0,   0,  83,   0,   0,   0, 
-    220,   6,   0,   0,  84,   0, 
-      0, 128, 220,   6,   0,   0, 
-     84,   0,   0,   0, 240,   6, 
+    192,   6,   0,   0,  83,   0, 
+      0, 128, 192,   6,   0,   0, 
+     83,   0,   0,   0, 220,   6, 
       0,   0,  84,   0,   0, 128, 
-    240,   6,   0,   0,  84,   0, 
-      0,   0,  12,   7,   0,   0, 
-     84,   0,   0, 128,  12,   7, 
+    220,   6,   0,   0,  84,   0, 
+      0,   0, 240,   6,   0,   0, 
+     84,   0,   0, 128, 240,   6, 
       0,   0,  84,   0,   0,   0, 
-     24,   7,   0,   0,  86,   0, 
-      0, 128,  24,   7,   0,   0, 
-     86,   0,   0,   0,  68,   7, 
+     12,   7,   0,   0,  84,   0, 
+      0, 128,  12,   7,   0,   0, 
+     84,   0,   0,   0,  24,   7, 
       0,   0,  86,   0,   0, 128, 
-     68,   7,   0,   0,  86,   0, 
-      0,   0, 112,   7,   0,   0, 
-     86,   0,   0, 128, 112,   7, 
+     24,   7,   0,   0,  86,   0, 
+      0,   0,  68,   7,   0,   0, 
+     86,   0,   0, 128,  68,   7, 
       0,   0,  86,   0,   0,   0, 
-    156,   7,   0,   0,  86,   0, 
-      0, 128, 156,   7,   0,   0, 
-     86,   0,   0,   0, 184,   7, 
+    112,   7,   0,   0,  86,   0, 
+      0, 128, 112,   7,   0,   0, 
+     86,   0,   0,   0, 156,   7, 
       0,   0,  86,   0,   0, 128, 
-    184,   7,   0,   0,  86,   0, 
-      0,   0, 212,   7,   0,   0, 
-     86,   0,   0, 128, 212,   7, 
+    156,   7,   0,   0,  86,   0, 
+      0,   0, 184,   7,   0,   0, 
+     86,   0,   0, 128, 184,   7, 
       0,   0,  86,   0,   0,   0, 
-    240,   7,   0,   0,  87,   0, 
-      0, 128, 240,   7,   0,   0, 
-     87,   0,   0,   0,   8,   8, 
+    212,   7,   0,   0,  86,   0, 
+      0, 128, 212,   7,   0,   0, 
+     86,   0,   0,   0, 240,   7, 
       0,   0,  87,   0,   0, 128, 
-      8,   8,   0,   0,  87,   0, 
-      0,   0,  36,   8,   0,   0, 
-     87,   0,   0, 128,  36,   8, 
+    240,   7,   0,   0,  87,   0, 
+      0,   0,   8,   8,   0,   0, 
+     87,   0,   0, 128,   8,   8, 
       0,   0,  87,   0,   0,   0, 
-     56,   8,   0,   0,  87,   0, 
-      0, 128,  56,   8,   0,   0, 
-     87,   0,   0,   0,  84,   8, 
+     36,   8,   0,   0,  87,   0, 
+      0, 128,  36,   8,   0,   0, 
+     87,   0,   0,   0,  56,   8, 
       0,   0,  87,   0,   0, 128, 
-     84,   8,   0,   0,  87,   0, 
-      0,   0, 112,   8,   0,   0, 
-     87,   0,   0, 128, 112,   8, 
+     56,   8,   0,   0,  87,   0, 
+      0,   0,  84,   8,   0,   0, 
+     87,   0,   0, 128,  84,   8, 
       0,   0,  87,   0,   0,   0, 
-    140,   8,   0,   0,  87,   0, 
-      0, 128, 140,   8,   0,   0, 
-     87,   0,   0,   0, 164,   8, 
+    112,   8,   0,   0,  87,   0, 
+      0, 128, 112,   8,   0,   0, 
+     87,   0,   0,   0, 140,   8, 
       0,   0,  87,   0,   0, 128, 
-    164,   8,   0,   0,  87,   0, 
-      0,   0, 192,   8,   0,   0, 
-     87,   0,   0, 128, 192,   8, 
+    140,   8,   0,   0,  87,   0, 
+      0,   0, 164,   8,   0,   0, 
+     87,   0,   0, 128, 164,   8, 
       0,   0,  87,   0,   0,   0, 
-    220,   8,   0,   0,  87,   0, 
-      0, 128, 220,   8,   0,   0, 
-     87,   0,   0,   0, 248,   8, 
+    192,   8,   0,   0,  87,   0, 
+      0, 128, 192,   8,   0,   0, 
+     87,   0,   0,   0, 220,   8, 
       0,   0,  87,   0,   0, 128, 
-    248,   8,   0,   0,  87,   0, 
-      0,   0,  12,   9,   0,   0, 
-     87,   0,   0, 128,  12,   9, 
+    220,   8,   0,   0,  87,   0, 
+      0,   0, 248,   8,   0,   0, 
+     87,   0,   0, 128, 248,   8, 
       0,   0,  87,   0,   0,   0, 
-     40,   9,   0,   0,  87,   0, 
-      0, 128,  40,   9,   0,   0, 
-     87,   0,   0,   0,  64,   9, 
+     12,   9,   0,   0,  87,   0, 
+      0, 128,  12,   9,   0,   0, 
+     87,   0,   0,   0,  40,   9, 
       0,   0,  87,   0,   0, 128, 
-     64,   9,   0,   0,  87,   0, 
-      0,   0,  96,   9,   0,   0, 
-     87,   0,   0, 128,  96,   9, 
+     40,   9,   0,   0,  87,   0, 
+      0,   0,  64,   9,   0,   0, 
+     87,   0,   0, 128,  64,   9, 
       0,   0,  87,   0,   0,   0, 
-    124,   9,   0,   0,  87,   0, 
-      0, 128, 124,   9,   0,   0, 
-     87,   0,   0,   0, 144,   9, 
+     96,   9,   0,   0,  87,   0, 
+      0, 128,  96,   9,   0,   0, 
+     87,   0,   0,   0, 124,   9, 
       0,   0,  87,   0,   0, 128, 
-    144,   9,   0,   0,  87,   0, 
-      0,   0, 172,   9,   0,   0, 
-     87,   0,   0, 128, 172,   9, 
+    124,   9,   0,   0,  87,   0, 
+      0,   0, 144,   9,   0,   0, 
+     87,   0,   0, 128, 144,   9, 
       0,   0,  87,   0,   0,   0, 
-    200,   9,   0,   0,  88,   0, 
-      0, 128, 200,   9,   0,   0, 
-     88,   0,   0,   0, 220,   9, 
+    172,   9,   0,   0,  87,   0, 
+      0, 128, 172,   9,   0,   0, 
+     87,   0,   0,   0, 200,   9, 
       0,   0,  88,   0,   0, 128, 
-    220,   9,   0,   0,  88,   0, 
-      0,   0, 248,   9,   0,   0, 
-     88,   0,   0, 128, 248,   9, 
+    200,   9,   0,   0,  88,   0, 
+      0,   0, 220,   9,   0,   0, 
+     88,   0,   0, 128, 220,   9, 
       0,   0,  88,   0,   0,   0, 
-      4,  10,   0,   0,  89,   0, 
-      0, 128,   4,  10,   0,   0, 
-     89,   0,   0,   0,  48,  10, 
+    248,   9,   0,   0,  88,   0, 
+      0, 128, 248,   9,   0,   0, 
+     88,   0,   0,   0,   4,  10, 
       0,   0,  89,   0,   0, 128, 
-     48,  10,   0,   0,  89,   0, 
-      0,   0,  92,  10,   0,   0, 
-     89,   0,   0, 128,  92,  10, 
+      4,  10,   0,   0,  89,   0, 
+      0,   0,  48,  10,   0,   0, 
+     89,   0,   0, 128,  48,  10, 
       0,   0,  89,   0,   0,   0, 
-    136,  10,   0,   0,  89,   0, 
-      0, 128, 136,  10,   0,   0, 
-     89,   0,   0,   0, 164,  10, 
+     92,  10,   0,   0,  89,   0, 
+      0, 128,  92,  10,   0,   0, 
+     89,   0,   0,   0, 136,  10, 
       0,   0,  89,   0,   0, 128, 
-    164,  10,   0,   0,  89,   0, 
-      0,   0, 192,  10,   0,   0, 
-     89,   0,   0, 128, 192,  10, 
+    136,  10,   0,   0,  89,   0, 
+      0,   0, 164,  10,   0,   0, 
+     89,   0,   0, 128, 164,  10, 
       0,   0,  89,   0,   0,   0, 
+    192,  10,   0,   0,  89,   0, 
+      0, 128, 192,  10,   0,   0, 
+     89,   0,   0,   0, 220,  10, 
+      0,   0,  89,   0,   0, 128, 
     220,  10,   0,   0,  89,   0, 
-      0, 128, 220,  10,   0,   0, 
-     89,   0,   0,   0, 224,  10, 
-      0,   0,  90,   0,   0, 128, 
-    224,  10,   0,   0,  90,   0, 
-      0,   0, 228,  10,   0,   0, 
-     91,   0,   0, 128, 228,  10, 
-      0,   0,  75,   0,   0,   0, 
+      0,   0, 224,  10,   0,   0, 
+     90,   0,   0, 128, 224,  10, 
+      0,   0,  90,   0,   0,   0, 
+    228,  10,   0,   0,  91,   0, 
+      0, 128, 228,  10,   0,   0, 
+     75,   0,   0,   0,   0,  11, 
+      0,   0,  91,   0,   0, 128, 
       0,  11,   0,   0,  91,   0, 
-      0, 128,   0,  11,   0,   0, 
-     91,   0,   0,   0,   4,  11, 
-      0,   0,  94,   0,   0, 128, 
-      4,  11,   0,   0,  94,   0, 
-      0,   0,  48,  11,   0,   0, 
-     95,   0,   0, 128,  48,  11, 
-      0,   0,  95,   0,   0,   0, 
+      0,   0,   4,  11,   0,   0, 
+     94,   0,   0, 128,   4,  11, 
+      0,   0,  94,   0,   0,   0, 
+     48,  11,   0,   0,  95,   0, 
+      0, 128,  48,  11,   0,   0, 
+     95,   0,   0,   0,  92,  11, 
+      0,   0,  95,   0,   0, 128, 
      92,  11,   0,   0,  95,   0, 
-      0, 128,  92,  11,   0,   0, 
-     95,   0,   0,   0, 104,  11, 
-      0,   0,  97,   0,   0, 128, 
-    104,  11,   0,   0,  97,   0, 
-      0,   0, 124,  11,   0,   0, 
-     97,   0,   0, 128, 124,  11, 
+      0,   0, 104,  11,   0,   0, 
+     97,   0,   0, 128, 104,  11, 
       0,   0,  97,   0,   0,   0, 
-    152,  11,   0,   0,  97,   0, 
-      0, 128, 152,  11,   0,   0, 
-     97,   0,   0,   0, 172,  11, 
+    124,  11,   0,   0,  97,   0, 
+      0, 128, 124,  11,   0,   0, 
+     97,   0,   0,   0, 152,  11, 
       0,   0,  97,   0,   0, 128, 
-    172,  11,   0,   0,  97,   0, 
-      0,   0, 200,  11,   0,   0, 
-     97,   0,   0, 128, 200,  11, 
+    152,  11,   0,   0,  97,   0, 
+      0,   0, 172,  11,   0,   0, 
+     97,   0,   0, 128, 172,  11, 
       0,   0,  97,   0,   0,   0, 
-    228,  11,   0,   0,  97,   0, 
-      0, 128, 228,  11,   0,   0, 
-     97,   0,   0,   0, 248,  11, 
+    200,  11,   0,   0,  97,   0, 
+      0, 128, 200,  11,   0,   0, 
+     97,   0,   0,   0, 228,  11, 
       0,   0,  97,   0,   0, 128, 
-    248,  11,   0,   0,  97,   0, 
-      0,   0,  20,  12,   0,   0, 
-     97,   0,   0, 128,  20,  12, 
+    228,  11,   0,   0,  97,   0, 
+      0,   0, 248,  11,   0,   0, 
+     97,   0,   0, 128, 248,  11, 
       0,   0,  97,   0,   0,   0, 
-     40,  12,   0,   0,  97,   0, 
-      0, 128,  40,  12,   0,   0, 
-     97,   0,   0,   0,  68,  12, 
+     20,  12,   0,   0,  97,   0, 
+      0, 128,  20,  12,   0,   0, 
+     97,   0,   0,   0,  40,  12, 
       0,   0,  97,   0,   0, 128, 
-     68,  12,   0,   0,  97,   0, 
-      0,   0,  96,  12,   0,   0, 
-     97,   0,   0, 128,  96,  12, 
+     40,  12,   0,   0,  97,   0, 
+      0,   0,  68,  12,   0,   0, 
+     97,   0,   0, 128,  68,  12, 
       0,   0,  97,   0,   0,   0, 
-    124,  12,   0,   0,  97,   0, 
-      0, 128, 124,  12,   0,   0, 
-     97,   0,   0,   0, 144,  12, 
+     96,  12,   0,   0,  97,   0, 
+      0, 128,  96,  12,   0,   0, 
+     97,   0,   0,   0, 124,  12, 
       0,   0,  97,   0,   0, 128, 
-    144,  12,   0,   0,  97,   0, 
-      0,   0, 172,  12,   0,   0, 
-     98,   0,   0, 128, 172,  12, 
-      0,   0,  98,   0,   0,   0, 
+    124,  12,   0,   0,  97,   0, 
+      0,   0, 144,  12,   0,   0, 
+     97,   0,   0, 128, 144,  12, 
+      0,   0,  97,   0,   0,   0, 
+    172,  12,   0,   0,  98,   0, 
+      0, 128, 172,  12,   0,   0, 
+     98,   0,   0,   0, 204,  12, 
+      0,   0,  98,   0,   0, 128, 
     204,  12,   0,   0,  98,   0, 
-      0, 128, 204,  12,   0,   0, 
-     98,   0,   0,   0, 216,  12, 
-      0,   0, 100,   0,   0, 128, 
-    216,  12,   0,   0, 100,   0, 
-      0,   0, 240,  12,   0,   0, 
-    100,   0,   0, 128, 240,  12, 
+      0,   0, 216,  12,   0,   0, 
+    100,   0,   0, 128, 216,  12, 
       0,   0, 100,   0,   0,   0, 
+    240,  12,   0,   0, 100,   0, 
+      0, 128, 240,  12,   0,   0, 
+    100,   0,   0,   0,  16,  13, 
+      0,   0, 100,   0,   0, 128, 
      16,  13,   0,   0, 100,   0, 
-      0, 128,  16,  13,   0,   0, 
-    100,   0,   0,   0,  44,  13, 
-      0,   0, 101,   0,   0, 128, 
-     44,  13,   0,   0, 101,   0, 
-      0,   0,  64,  13,   0,   0, 
-    101,   0,   0, 128,  64,  13, 
+      0,   0,  44,  13,   0,   0, 
+    101,   0,   0, 128,  44,  13, 
       0,   0, 101,   0,   0,   0, 
+     64,  13,   0,   0, 101,   0, 
+      0, 128,  64,  13,   0,   0, 
+    101,   0,   0,   0,  92,  13, 
+      0,   0, 101,   0,   0, 128, 
      92,  13,   0,   0, 101,   0, 
-      0, 128,  92,  13,   0,   0, 
-    101,   0,   0,   0, 104,  13, 
-      0,   0, 102,   0,   0, 128, 
-    104,  13,   0,   0, 102,   0, 
-      0,   0, 124,  13,   0,   0, 
-    102,   0,   0, 128, 124,  13, 
+      0,   0, 104,  13,   0,   0, 
+    102,   0,   0, 128, 104,  13, 
       0,   0, 102,   0,   0,   0, 
+    124,  13,   0,   0, 102,   0, 
+      0, 128, 124,  13,   0,   0, 
+    102,   0,   0,   0, 128,  13, 
+      0,   0, 103,   0,   0, 128, 
     128,  13,   0,   0, 103,   0, 
-      0, 128, 128,  13,   0,   0, 
-    103,   0,   0,   0, 172,  13, 
-      0,   0, 104,   0,   0, 128, 
-    172,  13,   0,   0, 104,   0, 
-      0,   0, 200,  13,   0,   0, 
-    104,   0,   0, 128, 200,  13, 
+      0,   0, 172,  13,   0,   0, 
+    104,   0,   0, 128, 172,  13, 
       0,   0, 104,   0,   0,   0, 
-    228,  13,   0,   0, 104,   0, 
-      0, 128, 228,  13,   0,   0, 
-    104,   0,   0,   0, 248,  13, 
+    200,  13,   0,   0, 104,   0, 
+      0, 128, 200,  13,   0,   0, 
+    104,   0,   0,   0, 228,  13, 
       0,   0, 104,   0,   0, 128, 
-    248,  13,   0,   0, 104,   0, 
-      0,   0,  20,  14,   0,   0, 
-    104,   0,   0, 128,  20,  14, 
+    228,  13,   0,   0, 104,   0, 
+      0,   0, 248,  13,   0,   0, 
+    104,   0,   0, 128, 248,  13, 
       0,   0, 104,   0,   0,   0, 
-     44,  14,   0,   0, 104,   0, 
-      0, 128,  44,  14,   0,   0, 
-    104,   0,   0,   0,  72,  14, 
+     20,  14,   0,   0, 104,   0, 
+      0, 128,  20,  14,   0,   0, 
+    104,   0,   0,   0,  44,  14, 
       0,   0, 104,   0,   0, 128, 
-     72,  14,   0,   0, 104,   0, 
-      0,   0, 100,  14,   0,   0, 
-    104,   0,   0, 128, 100,  14, 
+     44,  14,   0,   0, 104,   0, 
+      0,   0,  72,  14,   0,   0, 
+    104,   0,   0, 128,  72,  14, 
       0,   0, 104,   0,   0,   0, 
+    100,  14,   0,   0, 104,   0, 
+      0, 128, 100,  14,   0,   0, 
+    104,   0,   0,   0, 128,  14, 
+      0,   0, 105,   0,   0, 128, 
     128,  14,   0,   0, 105,   0, 
-      0, 128, 128,  14,   0,   0, 
-    105,   0,   0,   0, 132,  14, 
-      0,   0, 106,   0,   0, 128, 
-    132,  14,   0,   0, 106,   0, 
-      0,   0, 136,  14,   0,   0, 
-    107,   0,   0, 128, 136,  14, 
-      0,   0, 107,   0,   0,   0, 
-    168,  14,   0,   0, 107,   0, 
-      0, 128, 168,  14,   0,   0, 
-    107,   0,   0,   0, 200,  14, 
+      0,   0, 132,  14,   0,   0, 
+    106,   0,   0, 128, 132,  14, 
+      0,   0, 106,   0,   0,   0, 
+    136,  14,   0,   0, 107,   0, 
+      0, 128, 136,  14,   0,   0, 
+    107,   0,   0,   0, 168,  14, 
       0,   0, 107,   0,   0, 128, 
-    200,  14,   0,   0, 107,   0, 
-      0,   0, 228,  14,   0,   0, 
-    107,   0,   0, 128, 228,  14, 
+    168,  14,   0,   0, 107,   0, 
+      0,   0, 200,  14,   0,   0, 
+    107,   0,   0, 128, 200,  14, 
       0,   0, 107,   0,   0,   0, 
-      4,  15,   0,   0, 107,   0, 
-      0, 128,   4,  15,   0,   0, 
-    107,   0,   0,   0,  32,  15, 
+    228,  14,   0,   0, 107,   0, 
+      0, 128, 228,  14,   0,   0, 
+    107,   0,   0,   0,   4,  15, 
       0,   0, 107,   0,   0, 128, 
-     32,  15,   0,   0, 107,   0, 
-      0,   0,  72,  15,   0,   0, 
-    107,   0,   0, 128,  72,  15, 
+      4,  15,   0,   0, 107,   0, 
+      0,   0,  32,  15,   0,   0, 
+    107,   0,   0, 128,  32,  15, 
       0,   0, 107,   0,   0,   0, 
+     72,  15,   0,   0, 107,   0, 
+      0, 128,  72,  15,   0,   0, 
+    107,   0,   0,   0, 112,  15, 
+      0,   0, 108,   0,   0, 128, 
     112,  15,   0,   0, 108,   0, 
-      0, 128, 112,  15,   0,   0, 
-    108,   0,   0,   0, 132,  15, 
-      0,   0, 109,   0,   0, 128, 
-    132,  15,   0,   0, 109,   0, 
-      0,   0, 164,  15,   0,   0, 
-    109,   0,   0, 128, 164,  15, 
+      0,   0, 132,  15,   0,   0, 
+    109,   0,   0, 128, 132,  15, 
       0,   0, 109,   0,   0,   0, 
+    164,  15,   0,   0, 109,   0, 
+      0, 128, 164,  15,   0,   0, 
+    109,   0,   0,   0, 192,  15, 
+      0,   0, 109,   0,   0, 128, 
     192,  15,   0,   0, 109,   0, 
-      0, 128, 192,  15,   0,   0, 
-    109,   0,   0,   0, 204,  15, 
-      0,   0, 110,   0,   0, 128, 
-    204,  15,   0,   0, 110,   0, 
-      0,   0, 224,  15,   0,   0, 
-    110,   0,   0, 128, 224,  15, 
+      0,   0, 204,  15,   0,   0, 
+    110,   0,   0, 128, 204,  15, 
       0,   0, 110,   0,   0,   0, 
-    228,  15,   0,   0, 111,   0, 
-      0, 128, 228,  15,   0,   0, 
-    111,   0,   0,   0, 248,  15, 
+    224,  15,   0,   0, 110,   0, 
+      0, 128, 224,  15,   0,   0, 
+    110,   0,   0,   0, 228,  15, 
       0,   0, 111,   0,   0, 128, 
-    248,  15,   0,   0, 111,   0, 
-      0,   0,  12,  16,   0,   0, 
-    111,   0,   0, 128,  12,  16, 
+    228,  15,   0,   0, 111,   0, 
+      0,   0, 248,  15,   0,   0, 
+    111,   0,   0, 128, 248,  15, 
       0,   0, 111,   0,   0,   0, 
-      5,   0,  42,   0,  27,   0, 
-     41,   0,   5,   0,  43,   0, 
-     28,   0,  42,   0,   5,   0, 
-     48,   0,  14,   0,  18,   0, 
-      5,   0,  48,   0,   5,   0, 
+     12,  16,   0,   0, 111,   0, 
+      0, 128,  12,  16,   0,   0, 
+    111,   0,   0,   0,   5,   0, 
+     42,   0,  27,   0,  41,   0, 
+      5,   0,  43,   0,  28,   0, 
+     42,   0,   5,   0,  48,   0, 
+     14,   0,  18,   0,   5,   0, 
      48,   0,   5,   0,  48,   0, 
       5,   0,  48,   0,   5,   0, 
      48,   0,   5,   0,  48,   0, 
+      5,   0,  48,   0,   5,   0, 
+     48,   0,  21,   0,  41,   0, 
       5,   0,  48,   0,  21,   0, 
-     41,   0,   5,   0,  48,   0, 
-     21,   0,  41,   0,   9,   0, 
+     41,   0,   9,   0,  67,   0, 
+     33,   0,  49,   0,   9,   0, 
      67,   0,  33,   0,  49,   0, 
       9,   0,  67,   0,  33,   0, 
      49,   0,   9,   0,  67,   0, 
-     33,   0,  49,   0,   9,   0, 
-     67,   0,  32,   0,  59,   0, 
+     32,   0,  59,   0,   9,   0, 
+     67,   0,  13,   0,  61,   0, 
       9,   0,  67,   0,  13,   0, 
-     61,   0,   9,   0,  67,   0, 
+     65,   0,   9,   0,  67,   0, 
      13,   0,  65,   0,   9,   0, 
-     67,   0,  13,   0,  65,   0, 
-      9,   0,  67,   0,   9,   0, 
-     67,   0,  13,   0,  21,   0, 
-     44,   0,  46,   0,  13,   0, 
-     21,   0,  13,   0,  21,   0, 
+     67,   0,   9,   0,  67,   0, 
+     13,   0,  21,   0,  44,   0, 
+     46,   0,  13,   0,  21,   0, 
+     13,   0,  21,   0,  21,   0, 
      21,   0,  21,   0,  21,   0, 
-     21,   0,   9,   0, 100,   0, 
-     25,   0,  41,   0,   9,   0, 
-    100,   0,  25,   0,  41,   0, 
       9,   0, 100,   0,  25,   0, 
      41,   0,   9,   0, 100,   0, 
-     71,   0,  87,   0,   9,   0, 
-    100,   0,  71,   0,  87,   0, 
+     25,   0,  41,   0,   9,   0, 
+    100,   0,  25,   0,  41,   0, 
       9,   0, 100,   0,  71,   0, 
      87,   0,   9,   0, 100,   0, 
-     70,   0,  97,   0,   9,   0, 
-    100,   0,  51,   0,  99,   0, 
-      9,   0, 100,   0,  25,   0, 
-     99,   0,   9,   0, 100,   0, 
-      9,   0,  99,   0,  44,   0, 
-     46,   0,  44,   0,  46,   0, 
+     71,   0,  87,   0,   9,   0, 
+    100,   0,  71,   0,  87,   0, 
+      9,   0, 100,   0,  70,   0, 
+     97,   0,   9,   0, 100,   0, 
+     51,   0,  99,   0,   9,   0, 
+    100,   0,  25,   0,  99,   0, 
+      9,   0, 100,   0,   9,   0, 
+     99,   0,  44,   0,  46,   0, 
+     44,   0,  46,   0,   5,   0, 
       5,   0,   5,   0,   5,   0, 
-      5,   0,   5,   0,  46,   0, 
-     14,   0,  18,   0,   5,   0, 
-     46,   0,   5,   0,  46,   0, 
+      5,   0,  46,   0,  14,   0, 
+     18,   0,   5,   0,  46,   0, 
       5,   0,  46,   0,   5,   0, 
      46,   0,   5,   0,  46,   0, 
       5,   0,  46,   0,   5,   0, 
      46,   0,   5,   0,  46,   0, 
       5,   0,  46,   0,   5,   0, 
      46,   0,   5,   0,  46,   0, 
-     21,   0,  39,   0,   5,   0, 
-     46,   0,  21,   0,  39,   0, 
+      5,   0,  46,   0,  21,   0, 
+     39,   0,   5,   0,  46,   0, 
+     21,   0,  39,   0,   9,   0, 
+     73,   0,  27,   0,  42,   0, 
       9,   0,  73,   0,  27,   0, 
      42,   0,   9,   0,  73,   0, 
      27,   0,  42,   0,   9,   0, 
-     73,   0,  27,   0,  42,   0, 
+     73,   0,  27,   0,  72,   0, 
       9,   0,  73,   0,  27,   0, 
-     72,   0,   9,   0,  73,   0, 
-     27,   0,  72,   0,   9,   0, 
+     72,   0,   9,   0,  36,   0, 
+     13,   0,  30,   0,   9,   0, 
      36,   0,  13,   0,  30,   0, 
       9,   0,  36,   0,  13,   0, 
-     30,   0,   9,   0,  36,   0, 
+     34,   0,   9,   0,  36,   0, 
      13,   0,  34,   0,   9,   0, 
-     36,   0,  13,   0,  34,   0, 
-      9,   0,  36,   0,   9,   0, 
-     36,   0,  13,   0,  23,   0, 
-     13,   0,  22,   0,  23,   0, 
-     23,   0,  23,   0,  23,   0, 
-     13,   0,  66,   0,  22,   0, 
-     37,   0,  13,   0,  66,   0, 
+     36,   0,   9,   0,  36,   0, 
+     13,   0,  23,   0,  13,   0, 
+     22,   0,  23,   0,  23,   0, 
+     23,   0,  23,   0,  13,   0, 
+     66,   0,  22,   0,  37,   0, 
+     13,   0,  66,   0,  48,   0, 
+     65,   0,  13,   0,  66,   0, 
      48,   0,  65,   0,  13,   0, 
-     66,   0,  48,   0,  65,   0, 
-     13,   0,  66,   0,  22,   0, 
-     65,   0,  66,   0,  66,   0, 
-     66,   0,  66,   0,   9,   0, 
+     66,   0,  22,   0,  65,   0, 
+     66,   0,  66,   0,  66,   0, 
+     66,   0,   9,   0,  61,   0, 
+     38,   0,  58,   0,   9,   0, 
      61,   0,  38,   0,  58,   0, 
       9,   0,  61,   0,  38,   0, 
      58,   0,   9,   0,  61,   0, 
-     38,   0,  58,   0,   9,   0, 
-     61,   0,  19,   0,  60,   0, 
+     19,   0,  60,   0,   9,   0, 
+     19,   0,  13,   0,  17,   0, 
       9,   0,  19,   0,  13,   0, 
      17,   0,   9,   0,  19,   0, 
-     13,   0,  17,   0,   9,   0, 
-     19,   0,   9,   0,  19,   0, 
+      9,   0,  19,   0,  13,   0, 
+     64,   0,  29,   0,  44,   0, 
      13,   0,  64,   0,  29,   0, 
      44,   0,  13,   0,  64,   0, 
      29,   0,  44,   0,  13,   0, 
-     64,   0,  29,   0,  44,   0, 
+     64,   0,  29,   0,  54,   0, 
      13,   0,  64,   0,  29,   0, 
-     54,   0,  13,   0,  64,   0, 
-     29,   0,  63,   0,  13,   0, 
-     64,   0,  13,   0,  63,   0, 
-     13,   0, 133,   0,  53,   0, 
-     61,   0,  13,   0, 133,   0, 
-     42,   0,  63,   0,  13,   0, 
-    133,   0,  42,   0,  63,   0, 
+     63,   0,  13,   0,  64,   0, 
+     13,   0,  63,   0,  13,   0, 
+    133,   0,  53,   0,  61,   0, 
      13,   0, 133,   0,  42,   0, 
      63,   0,  13,   0, 133,   0, 
+     42,   0,  63,   0,  13,   0, 
+    133,   0,  42,   0,  63,   0, 
+     13,   0, 133,   0,  33,   0, 
+     79,   0,  13,   0, 133,   0, 
      33,   0,  79,   0,  13,   0, 
     133,   0,  33,   0,  79,   0, 
      13,   0, 133,   0,  33,   0, 
      79,   0,  13,   0, 133,   0, 
      33,   0,  79,   0,  13,   0, 
-    133,   0,  33,   0,  79,   0, 
+    133,   0,  22,   0,  81,   0, 
      13,   0, 133,   0,  22,   0, 
      81,   0,  13,   0, 133,   0, 
      22,   0,  81,   0,  13,   0, 
-    133,   0,  22,   0,  81,   0, 
+    133,   0,  95,   0, 128,   0, 
      13,   0, 133,   0,  95,   0, 
     128,   0,  13,   0, 133,   0, 
-     95,   0, 128,   0,  13,   0, 
+     84,   0, 130,   0,  13,   0, 
     133,   0,  84,   0, 130,   0, 
      13,   0, 133,   0,  84,   0, 
     130,   0,  13,   0, 133,   0, 
-     84,   0, 130,   0,  13,   0, 
-    133,   0,  17,   0, 132,   0, 
+     17,   0, 132,   0,  13,   0, 
+     23,   0,  17,   0,  21,   0, 
      13,   0,  23,   0,  17,   0, 
      21,   0,  13,   0,  23,   0, 
-     17,   0,  21,   0,  13,   0, 
-     23,   0,  13,   0,  23,   0, 
+     13,   0,  23,   0,  17,   0, 
+     69,   0,  34,   0,  49,   0, 
      17,   0,  69,   0,  34,   0, 
      49,   0,  17,   0,  69,   0, 
      34,   0,  49,   0,  17,   0, 
-     69,   0,  34,   0,  49,   0, 
+     69,   0,  34,   0,  59,   0, 
      17,   0,  69,   0,  34,   0, 
-     59,   0,  17,   0,  69,   0, 
-     34,   0,  68,   0,  17,   0, 
-     69,   0,  17,   0,  68,   0, 
+     68,   0,  17,   0,  69,   0, 
+     17,   0,  68,   0,  69,   0, 
      69,   0,  69,   0,  69,   0, 
-     69,   0,   9,   0,   9,   0, 
-      9,   0,   9,   0,   5,   0, 
-      5,   0,  42,   0,  44,   0, 
+      9,   0,   9,   0,   9,   0, 
+      9,   0,   5,   0,   5,   0, 
+     42,   0,  44,   0,   5,   0, 
       5,   0,   5,   0,   5,   0, 
-      5,   0,   5,   0,  73,   0, 
-     28,   0,  72,   0,   5,   0, 
-     23,   0,   9,   0,  21,   0, 
-      5,   0,  23,   0,   5,   0, 
-     23,   0,   9,   0, 134,   0, 
+      5,   0,  73,   0,  28,   0, 
+     72,   0,   5,   0,  23,   0, 
+      9,   0,  21,   0,   5,   0, 
+     23,   0,   5,   0,  23,   0, 
+      9,   0, 134,   0,  29,   0, 
+     46,   0,   9,   0, 134,   0, 
      29,   0,  46,   0,   9,   0, 
-    134,   0,  29,   0,  46,   0, 
+    134,   0,  52,   0,  69,   0, 
       9,   0, 134,   0,  52,   0, 
      69,   0,   9,   0, 134,   0, 
-     52,   0,  69,   0,   9,   0, 
-    134,   0,  28,   0,  70,   0, 
+     28,   0,  70,   0,   9,   0, 
+    134,   0,  75,   0,  92,   0, 
       9,   0, 134,   0,  75,   0, 
      92,   0,   9,   0, 134,   0, 
-     75,   0,  92,   0,   9,   0, 
+     98,   0, 115,   0,   9,   0, 
     134,   0,  98,   0, 115,   0, 
-      9,   0, 134,   0,  98,   0, 
-    115,   0,   9,   0, 134,   0, 
-     74,   0, 116,   0,   9,   0, 
-    134,   0,  28,   0, 116,   0, 
+      9,   0, 134,   0,  74,   0, 
+    116,   0,   9,   0, 134,   0, 
+     28,   0, 116,   0,   9,   0, 
+    134,   0,  22,   0, 118,   0, 
       9,   0, 134,   0,  22,   0, 
-    118,   0,   9,   0, 134,   0, 
-     22,   0, 133,   0,   9,   0, 
-     37,   0,  13,   0,  35,   0, 
-      9,   0,  37,   0,   9,   0, 
-     37,   0,  13,   0,  69,   0, 
+    133,   0,   9,   0,  37,   0, 
+     13,   0,  35,   0,   9,   0, 
+     37,   0,   9,   0,  37,   0, 
+     13,   0,  69,   0,  38,   0, 
+     60,   0,  13,   0,  69,   0, 
      38,   0,  60,   0,  13,   0, 
-     69,   0,  38,   0,  60,   0, 
-     13,   0,  69,   0,  37,   0, 
-     68,   0,  13,   0,  37,   0, 
+     69,   0,  37,   0,  68,   0, 
+     13,   0,  37,   0,  17,   0, 
+     35,   0,  13,   0,  37,   0, 
      17,   0,  35,   0,  13,   0, 
-     37,   0,  17,   0,  35,   0, 
-     13,   0,  37,   0,  13,   0, 
-     37,   0,  17,   0,  38,   0, 
-     17,   0,  37,   0,  38,   0, 
-     38,   0,  38,   0,  38,   0, 
-     13,   0,  83,   0,  34,   0, 
-     82,   0,  13,   0, 132,   0, 
-     44,   0,  74,   0,  13,   0, 
-    132,   0,  29,   0,  75,   0, 
-     13,   0, 132,   0,  96,   0, 
-    130,   0,  13,   0, 132,   0, 
-    100,   0, 130,   0,  13,   0, 
+     37,   0,  13,   0,  37,   0, 
+     17,   0,  38,   0,  17,   0, 
+     37,   0,  38,   0,  38,   0, 
+     38,   0,  38,   0,  13,   0, 
+     83,   0,  34,   0,  82,   0, 
+     13,   0, 132,   0,  44,   0, 
+     74,   0,  13,   0, 132,   0, 
+     29,   0,  75,   0,  13,   0, 
     132,   0,  96,   0, 130,   0, 
-     13,   0, 132,   0,  96,   0, 
+     13,   0, 132,   0, 100,   0, 
     130,   0,  13,   0, 132,   0, 
-     79,   0, 131,   0,  13,   0, 
-    132,   0,  29,   0, 131,   0, 
+     96,   0, 130,   0,  13,   0, 
+    132,   0,  96,   0, 130,   0, 
+     13,   0, 132,   0,  79,   0, 
+    131,   0,  13,   0, 132,   0, 
+     29,   0, 131,   0,   9,   0, 
       9,   0,   9,   0,   9,   0, 
-      9,   0,   5,   0,   5,   0, 
       5,   0,   5,   0,   5,   0, 
-    229,   0,  38,   0,  66,   0, 
-      5,   0, 229,   0,  72,   0, 
-    143,   0,   5,   0, 229,   0, 
-     37,   0, 144,   0,   5,   0, 
-    229,   0, 149,   0, 225,   0, 
+      5,   0,   5,   0, 229,   0, 
+     38,   0,  66,   0,   5,   0, 
+    229,   0,  72,   0, 143,   0, 
       5,   0, 229,   0,  37,   0, 
-    226,   0,   5,   0, 229,   0, 
+    144,   0,   5,   0, 229,   0, 
+    149,   0, 225,   0,   5,   0, 
+    229,   0,  37,   0, 226,   0, 
+      5,   0, 229,   0,  27,   0, 
+    228,   0,   5,   0, 229,   0, 
      27,   0, 228,   0,   5,   0, 
-    229,   0,  27,   0, 228,   0, 
-      5,   0,  37,   0,   5,   0, 
-     36,   0,   5,   0,  48,   0, 
-     16,   0,  44,   0,   5,   0, 
-     48,   0,   9,   0,  46,   0, 
-      5,   0,  48,   0,   5,   0, 
-     48,   0,   9,   0,  37,   0, 
-      9,   0,  36,   0,  37,   0, 
-     37,   0,  37,   0,  37,   0, 
-      5,   0,  24,   0,   5,   0, 
-     24,   0,   5,   0,  24,   0, 
+     37,   0,   5,   0,  36,   0, 
+      5,   0,  48,   0,  16,   0, 
+     44,   0,   5,   0,  48,   0, 
+      9,   0,  46,   0,   5,   0, 
+     48,   0,   5,   0,  48,   0, 
+      9,   0,  37,   0,   9,   0, 
+     36,   0,  37,   0,  37,   0, 
+     37,   0,  37,   0,   5,   0, 
+     24,   0,   5,   0,  24,   0, 
       5,   0,  24,   0,   5,   0, 
      24,   0,   5,   0,  24,   0, 
-    246,   0,   0,   0,   4,   0, 
-      0,   0,   0,   0,   0,   0, 
-     56,   0,   0,   0,   0,   0, 
-      0,   0,  36,   0,   0,   0, 
-     72,   0,   0,   0, 104,   0, 
-      0,   0, 136,   0,   0,   0, 
-    172,   0,   0,   0, 208,   0, 
-      0,   0, 244,   0,   0,   0, 
-     28,   1,   0,   0,  64,   1, 
-      0,   0, 100,   1,   0,   0, 
-    140,   1,   0,   0, 176,   1, 
-      0,   0, 208,   1,   0,   0, 
+      5,   0,  24,   0, 246,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0,  56,   0, 
       0,   0,   0,   0,   0,   0, 
+     36,   0,   0,   0,  72,   0, 
+      0,   0, 104,   0,   0,   0, 
+    136,   0,   0,   0, 172,   0, 
+      0,   0, 208,   0,   0,   0, 
+    244,   0,   0,   0,  28,   1, 
+      0,   0,  64,   1,   0,   0, 
+    100,   1,   0,   0, 140,   1, 
+      0,   0, 176,   1,   0,   0, 
+    208,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -4194,37 +4108,42 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,  23,  21,  22,  16,   0, 
-      0,  26,   2,   0,   0,   0, 
-      0,  10,   0,  24,  21,  23, 
-     16,   0,   0,   1,   0,   1, 
-      0,  10,   0,  24,  21,  24, 
-     16,   0,   0,   1,   0,   0, 
-      2,  58,   0,   3,  18,  13, 
-     21,   3,   0,   2,  16,   0, 
-      0,   0,   0, 112, 111, 115, 
-    105, 116, 105, 111, 110,   0, 
-    241,  13,  21,   3,   0,   2, 
-     16,   0,   0,  16,   0,  99, 
-    111, 108, 111, 114,   0,  13, 
-     21,   3,   0,  64,   0,   0, 
-      0,  28,   0, 114,  97, 100, 
-    105, 117, 115,   0, 243, 242, 
-    241,  31,   0,   5,  21,   3, 
-      0,   0,   0,  26,  16,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  32,   0,  80, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,   0,  12,   0, 
-     23,  21,  27,  16,   0,   0, 
-     26,   2,   0,   0,   0,   0, 
-     10,   0,  24,  21,  28,  16, 
+      0,   0,   0,   0,  28,   0, 
+     68, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+      0, 241,  14,   0,  23,  21, 
+     22,  16,   0,   0,  26,   2, 
+      0,   0,   0,   0, 242, 241, 
+     10,   0,  24,  21,  23,  16, 
       0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,  29,  16, 
+     10,   0,  24,  21,  24,  16, 
       0,   0,   1,   0,   0,   2, 
-     12,   0,  23,  21,   0,  16, 
-      0,   0,   3,   2,   0,   0, 
-      0,   0,  10,   0,  24,  21, 
+     58,   0,   3,  18,  13,  21, 
+      3,   0,   2,  16,   0,   0, 
+      0,   0, 112, 111, 115, 105, 
+    116, 105, 111, 110,   0, 241, 
+     13,  21,   3,   0,   2,  16, 
+      0,   0,  16,   0,  99, 111, 
+    108, 111, 114,   0,  13,  21, 
+      3,   0,  64,   0,   0,   0, 
+     28,   0, 114,  97, 100, 105, 
+    117, 115,   0, 243, 242, 241, 
+     34,   0,   5,  21,   3,   0, 
+      0,   0,  26,  16,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  32,   0,  80, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116,   0, 243, 242, 241, 
+     14,   0,  23,  21,  27,  16, 
+      0,   0,  26,   2,   0,   0, 
+      0,   0, 242, 241,  10,   0, 
+     24,  21,  28,  16,   0,   0, 
+      1,   0,   1,   0,  10,   0, 
+     24,  21,  29,  16,   0,   0, 
+      1,   0,   0,   2,  14,   0, 
+     23,  21,   0,  16,   0,   0, 
+      3,   2,   0,   0,   0,   0, 
+    242, 241,  10,   0,  24,  21, 
      31,  16,   0,   0,   1,   0, 
       1,   0,  10,   0,  24,  21, 
      32,  16,   0,   0,   1,   0, 
@@ -4275,102 +4194,97 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  11, 202,  49,   1, 
-     56,   0,   0,   0,   0,  16, 
-      0,   0,  34,  16,   0,   0, 
-    150,   2,   0,   0,  11,   0, 
-    255, 255,   4,   0,   0,   0, 
-    255, 255,   3,   0,   0,   0, 
-      0,   0, 136,   0,   0,   0, 
-    136,   0,   0,   0,   8,   0, 
-      0,   0, 144,   0,   0,   0, 
-      0,   0,   0,   0,  19,   0, 
-     27,  21,  64,   0,   0,   0, 
-      4,   0,   0,   0,  16,   0, 
-    102, 108, 111,  97, 116,  52, 
-      0,  19,   0,  27,  21,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   8,   0, 102, 108, 111, 
-     97, 116,  50,   0,  19,   0, 
-     27,  21,  64,   0,   0,   0, 
-      3,   0,   0,   0,  12,   0, 
-    102, 108, 111,  97, 116,  51, 
-      0,  78,   0,   3,  18,  13, 
-     21,   3,   0,   0,  16,   0, 
-      0,   0,   0, 119, 111, 114, 
-    108, 100,  80, 111, 115,   0, 
-    241,  13,  21,   3,   0,   0, 
-     16,   0,   0,  16,   0, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,   0, 241,  13,  21,   3, 
-      0,   1,  16,   0,   0,  32, 
-      0, 116, 101, 120,   0, 242, 
-    241,  13,  21,   3,   0,   2, 
-     16,   0,   0,  40,   0, 110, 
-    111, 114, 109,  97, 108,   0, 
-    243, 242, 241,  35,   0,   5, 
-     21,   4,   0,   0,   0,   3, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,  52, 
-      0,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,   0,  10,   0, 
-      1,  18,   1,   0,   0,   0, 
-      4,  16,   0,   0,  10,   0, 
-     24,  21,   0,  16,   0,   0, 
-      1,   0,   1,   0,  14,   0, 
-      8,  16,   6,  16,   0,   0, 
-     23,   0,   1,   0,   5,  16, 
-      0,   0,  12,   0,  23,  21, 
-      0,  16,   0,   0,   3,   2, 
-      0, 229,   0,   0,  10,   0, 
+     11, 202,  49,   1,  56,   0, 
+      0,   0,   0,  16,   0,   0, 
+     34,  16,   0,   0, 176,   2, 
+      0,   0,  10,   0, 255, 255, 
+      4,   0,   0,   0, 255, 255, 
+      3,   0,   0,   0,   0,   0, 
+    136,   0,   0,   0, 136,   0, 
+      0,   0,   8,   0,   0,   0, 
+    144,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  27,  21, 
+     64,   0,   0,   0,   4,   0, 
+      0,   0,  16,   0, 102, 108, 
+    111,  97, 116,  52,   0, 243, 
+    242, 241,  22,   0,  27,  21, 
+     64,   0,   0,   0,   2,   0, 
+      0,   0,   8,   0, 102, 108, 
+    111,  97, 116,  50,   0, 243, 
+    242, 241,  22,   0,  27,  21, 
+     64,   0,   0,   0,   3,   0, 
+      0,   0,  12,   0, 102, 108, 
+    111,  97, 116,  51,   0, 243, 
+    242, 241,  78,   0,   3,  18, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,   0,   0, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+      0, 241,  13,  21,   3,   0, 
+      0,  16,   0,   0,  16,   0, 
+    112, 111, 115, 105, 116, 105, 
+    111, 110,   0, 241,  13,  21, 
+      3,   0,   1,  16,   0,   0, 
+     32,   0, 116, 101, 120,   0, 
+    242, 241,  13,  21,   3,   0, 
+      2,  16,   0,   0,  40,   0, 
+    110, 111, 114, 109,  97, 108, 
+      0, 243, 242, 241,  38,   0, 
+      5,  21,   4,   0,   0,   0, 
+      3,  16,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     52,   0,  80, 105, 120, 101, 
+    108,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,   0, 243, 
+    242, 241,  10,   0,   1,  18, 
+      1,   0,   0,   0,   4,  16, 
+      0,   0,  10,   0,  24,  21, 
+      0,  16,   0,   0,   1,   0, 
+      1,   0,  14,   0,   8,  16, 
+      6,  16,   0,   0,  23,   0, 
+      1,   0,   5,  16,   0,   0, 
+     14,   0,  23,  21,   0,  16, 
+      0,   0,   3,   2,   0, 229, 
+      0,   0, 242, 241,  10,   0, 
      24,  21,   8,  16,   0,   0, 
       1,   0,   1,   0,  10,   0, 
      24,  21,   9,  16,   0,   0, 
-      1,   0,   0,   2,  12,   0, 
+      1,   0,   0,   2,  14,   0, 
      23,  21,   0,   0,   0,   0, 
-     10,   2,   0,   0,   0,   0, 
-     10,   0,  24,  21,  11,  16, 
-      0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,  12,  16, 
-      0,   0,   1,   0,   0,   2, 
-     10,   0,  24,  21,   6,  16, 
-      0,   0,   1,   0,   0,   2, 
-     10,   0,  24,  21,  64,   0, 
-      0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,  15,  16, 
-      0,   0,   1,   0,   0,   2, 
-     10,   0,  24,  21, 116,   0, 
-      0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,  17,  16, 
-      0,   0,   1,   0,   0,   2, 
-     10,   0,  24,  21,  98,   0, 
-      0,   0,   1,   0,   1,   0, 
-     10,   0,  24,  21,  19,  16, 
-      0,   0,   1,   0,   0,   2, 
-     38,   0,   3,  18,  13,  21, 
-      3,   0,   2,  16,   0,   0, 
-      0,   0, 100, 105, 114, 101, 
-     99, 116, 105, 111, 110,   0, 
+     10,   2,   0, 229,   0,   0, 
+    242, 241,  10,   0,  24,  21, 
+     11,  16,   0,   0,   1,   0, 
+      1,   0,  10,   0,  24,  21, 
+     12,  16,   0,   0,   1,   0, 
+      0,   2,  10,   0,  24,  21, 
+      6,  16,   0,   0,   1,   0, 
+      0,   2,  10,   0,  24,  21, 
+     64,   0,   0,   0,   1,   0, 
+      1,   0,  10,   0,  24,  21, 
+     15,  16,   0,   0,   1,   0, 
+      0,   2,  10,   0,  24,  21, 
+    116,   0,   0,   0,   1,   0, 
+      1,   0,  10,   0,  24,  21, 
+     17,  16,   0,   0,   1,   0, 
+      0,   2,  10,   0,  24,  21, 
+     98,   0,   0,   0,   1,   0, 
+      1,   0,  10,   0,  24,  21, 
+     19,  16,   0,   0,   1,   0, 
+      0,   2,  38,   0,   3,  18, 
      13,  21,   3,   0,   2,  16, 
-      0,   0,  16,   0,  99, 111, 
-    108, 111, 114,   0,  33,   0, 
-      5,  21,   2,   0,   0,   0, 
-     21,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     28,   0,  68, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,   0,  12,  11, 202, 
-     49,   1,  56,   0,   0,   0, 
-      0,  16,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0, 255, 255,   4,   0, 
-      0,   0, 255, 255,   3,   0, 
+      0,   0,   0,   0, 100, 105, 
+    114, 101,  99, 116, 105, 111, 
+    110,   0,  13,  21,   3,   0, 
+      2,  16,   0,   0,  16,   0, 
+     99, 111, 108, 111, 114,   0, 
+     34,   0,   5,  21,   2,   0, 
+      0,   0,  21,  16,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,  11, 202,  49,   1, 
+     56,   0,   0,   0,   0,  16, 
+      0,   0,   0,  16,   0,   0, 
+      0,   0,   0,   0,  11,   0, 
+    255, 255,   4,   0,   0,   0, 
+    255, 255,   3,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -4450,64 +4364,64 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    111,  97, 116,  51,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  59,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32,  99, 111, 108, 
-    111, 114,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32, 114,  97, 100, 
-    105, 117, 115,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
-     99,  98, 117, 102, 102, 101, 
-    114,  32,  84, 101, 120, 116, 
-    117, 114,  69, 102, 102, 101, 
-     99, 116,  32,  58,  32, 114, 
-    101, 103, 105, 115, 116, 101, 
-    114,  40,  98,  51,  41,  13, 
-     10, 123,  13,  10,  32,  32, 
-     32,  32,  98, 111, 111, 108, 
+      0,   0,   0,   0, 111,  97, 
+    116,  51,  32, 112, 111, 115, 
+    105, 116, 105, 111, 110,  59, 
+     13,  10,  32,  32,  32,  32, 
+    102, 108, 111,  97, 116,  51, 
+     32,  99, 111, 108, 111, 114, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     32, 114,  97, 100, 105, 117, 
+    115,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  99,  98, 
+    117, 102, 102, 101, 114,  32, 
+     84, 101, 120, 116, 117, 114, 
+     69, 102, 102, 101,  99, 116, 
+     32,  58,  32, 114, 101, 103, 
+    105, 115, 116, 101, 114,  40, 
+     98,  51,  41,  13,  10, 123, 
+     13,  10,  32,  32,  32,  32, 
+     98, 111, 111, 108,  32, 101, 
+    102, 102, 101,  99, 116,  69, 
+    110,  97,  98, 108, 101, 100, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
      32, 101, 102, 102, 101,  99, 
-    116,  69, 110,  97,  98, 108, 
-    101, 100,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  32, 101, 102, 102, 
-    101,  99, 116,  80, 101, 114, 
-     99, 101, 110, 116,  97, 103, 
-    101,  59,  13,  10, 125,  59, 
-     13,  10,  13,  10,  83, 116, 
-    114, 117,  99, 116, 117, 114, 
-    101, 100,  66, 117, 102, 102, 
-    101, 114,  60,  32,  68, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  32,  62, 
-     32, 100, 105, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-    115,  32,  58,  32, 114, 101, 
-    103, 105, 115, 116, 101, 114, 
-     40, 116,  49,  41,  59,  13, 
-     10,  83, 116, 114, 117,  99, 
-    116, 117, 114, 101, 100,  66, 
-    117, 102, 102, 101, 114,  60, 
-     32,  80, 111, 105, 110, 116, 
-     76, 105, 103, 104, 116,  32, 
-     62,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-    115,  32,  58,  32, 114, 101, 
-    103, 105, 115, 116, 101, 114, 
-     40, 116,  50,  41,  59,  13, 
-     10,  84, 101, 120, 116, 117, 
-    114, 101,  50,  68,  32,  97, 
-    100, 100, 105, 116, 105, 111, 
-    110,  97, 108,  84, 101, 120, 
-    116, 117, 114, 101,  32,  58, 
-     32, 114, 101, 103, 105, 115, 
-    116, 101, 114,  40, 116,  51, 
-     41,  59,  13,  10,  13,  10, 
+    116,  80, 101, 114,  99, 101, 
+    110, 116,  97, 103, 101,  59, 
+     13,  10, 125,  59,  13,  10, 
+     13,  10,  83, 116, 114, 117, 
+     99, 116, 117, 114, 101, 100, 
+     66, 117, 102, 102, 101, 114, 
+     60,  32,  68, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  32,  62,  32, 100, 
+    105, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116, 115,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40, 116, 
+     49,  41,  59,  13,  10,  83, 
+    116, 114, 117,  99, 116, 117, 
+    114, 101, 100,  66, 117, 102, 
+    102, 101, 114,  60,  32,  80, 
+    111, 105, 110, 116,  76, 105, 
+    103, 104, 116,  32,  62,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40, 116, 
+     50,  41,  59,  13,  10,  84, 
+    101, 120, 116, 117, 114, 101, 
+     50,  68,  32,  97, 100, 100, 
+    105, 116, 105, 111, 110,  97, 
+    108,  84, 101, 120, 116, 117, 
+    114, 101,  32,  58,  32, 114, 
+    101, 103, 105, 115, 116, 101, 
+    114,  40, 116,  51,  41,  59, 
+     13,  10,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -4522,10 +4436,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  84,  89,  80,  69,  68, 
-     69,  70,  83,  32,  47,  47, 
      32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  32,  84, 
+     89,  80,  69,  68,  69,  70, 
+     83,  32,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -4540,9 +4454,10 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  47,  47, 
+     32,  32,  32,  32,  13,  10, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -4557,34 +4472,34 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  13,  10, 123, 
+     32,  32,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  13,  10, 123,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  52,  32, 119, 
+    111, 114, 108, 100,  80, 111, 
+    115,  32,  58,  32,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     52,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32,  58, 
+     32,  83,  86,  95,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 108, 111,  97, 116, 
+     50,  32, 116, 101, 120,  32, 
+     58,  32,  84,  69,  88,  67, 
+     79,  79,  82,  68,  48,  59, 
      13,  10,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  52, 
-     32, 119, 111, 114, 108, 100, 
-     80, 111, 115,  32,  58,  32, 
-     80,  79,  83,  73,  84,  73, 
-     79,  78,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  52,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32,  58,  32,  83,  86,  95, 
-     80,  79,  83,  73,  84,  73, 
-     79,  78,  59,  13,  10,  32, 
-     32,  32,  32, 102, 108, 111, 
-     97, 116,  50,  32, 116, 101, 
-    120,  32,  58,  32,  84,  69, 
+    102, 108, 111,  97, 116,  51, 
+     32, 110, 111, 114, 109,  97, 
+    108,  32,  58,  32,  84,  69, 
      88,  67,  79,  79,  82,  68, 
-     48,  59,  13,  10,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 110, 111, 114, 
-    109,  97, 108,  32,  58,  32, 
-     84,  69,  88,  67,  79,  79, 
-     82,  68,  49,  59,  13,  10, 
-    125,  59,  13,  10,  13,  10, 
+     49,  59,  13,  10, 125,  59, 
+     13,  10,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -4598,14 +4513,13 @@ const BYTE UIPixelShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  80, 105, 120, 101, 108, 
-     32,  83, 104,  97, 100, 101, 
-    114,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     13,  10,  47,  47,  32,  80, 
+    105, 120, 101, 108,  32,  83, 
+    104,  97, 100, 101, 114,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -4620,7 +4534,7 @@ const BYTE UIPixelShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     13,  10,  47,  47,  47,  47, 
+     32,  32,  32,  32,  13,  10, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -4633,70 +4547,49 @@ const BYTE UIPixelShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-    102, 108, 111,  97, 116,  52, 
-     32,  84, 101, 120, 116, 117, 
-    114, 101,  80, 105, 120, 101, 
-    108,  83, 104,  97, 100, 101, 
-    114,  40,  32,  80, 105, 120, 
-    101, 108,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,  32, 
-    105, 110, 112, 117, 116,  32, 
-     41,  32,  58,  32,  83,  86, 
-     95,  84,  65,  82,  71,  69, 
-     84,  13,  10, 123,  13,  10, 
-     32,  32,  32,  32, 102, 108, 
-    111,  97, 116,  51,  32, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  32, 
-     61,  32, 102, 108, 111,  97, 
-    116,  51,  40,  48,  44,  32, 
-     48,  44,  32,  48,  41,  59, 
-     13,  10,  32,  32,  32,  32, 
+     32,  32,  13,  10, 102, 108, 
+    111,  97, 116,  52,  32,  84, 
+    101, 120, 116, 117, 114, 101, 
+     80, 105, 120, 101, 108,  83, 
+    104,  97, 100, 101, 114,  40, 
+     32,  80, 105, 120, 101, 108, 
+     73, 110, 112, 117, 116,  84, 
+    121, 112, 101,  32, 105, 110, 
+    112, 117, 116,  32,  41,  32, 
+     58,  32,  83,  86,  95,  84, 
+     65,  82,  71,  69,  84,  13, 
+     10, 123,  13,  10,  32,  32, 
+     32,  32, 102, 108, 111,  97, 
+    116,  51,  32, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  32,  61,  32, 
     102, 108, 111,  97, 116,  51, 
-     32, 115, 112, 101,  99, 117, 
-    108,  97, 114,  76, 105, 103, 
-    104, 116,  32,  61,  32, 102, 
-    108, 111,  97, 116,  51,  40, 
-     48,  44,  32,  48,  44,  32, 
-     48,  41,  59,  13,  10,  32, 
-     32,  32,  32, 102, 111, 114, 
-     40,  32, 105, 110, 116,  32, 
-    106,  32,  61,  32,  48,  59, 
-     32, 106,  32,  60,  32, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  67, 
-    111, 117, 110, 116,  59,  32, 
-    106,  43,  43,  32,  41,  13, 
-     10,  32,  32,  32,  32, 123, 
-     13,  10,  32,  32,  32,  32, 
-     32,  32,  32,  32, 105, 102, 
-     40,  32, 100, 111, 116,  40, 
-     32, 105, 110, 112, 117, 116, 
-     46, 110, 111, 114, 109,  97, 
-    108,  44,  32,  45, 100, 105, 
+     40,  48,  44,  32,  48,  44, 
+     32,  48,  41,  59,  13,  10, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  51,  32, 115, 
+    112, 101,  99, 117, 108,  97, 
+    114,  76, 105, 103, 104, 116, 
+     32,  61,  32, 102, 108, 111, 
+     97, 116,  51,  40,  48,  44, 
+     32,  48,  44,  32,  48,  41, 
+     59,  13,  10,  32,  32,  32, 
+     32, 102, 111, 114,  40,  32, 
+    105, 110, 116,  32, 106,  32, 
+     61,  32,  48,  59,  32, 106, 
+     32,  60,  32, 100, 105, 102, 
     102, 117, 115, 101,  76, 105, 
-    103, 104, 116, 115,  91,  32, 
-    106,  32,  93,  46, 100, 105, 
-    114, 101,  99, 116, 105, 111, 
-    110,  32,  41,  32,  60,  32, 
-     48,  32,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  99, 
-    111, 110, 116, 105, 110, 117, 
-    101,  59,  13,  10,  32,  32, 
+    103, 104, 116,  67, 111, 117, 
+    110, 116,  59,  32, 106,  43, 
+     43,  32,  41,  13,  10,  32, 
+     32,  32,  32, 123,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     32,  43,  61,  32, 100, 105, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116, 115,  91,  32, 
-    106,  32,  93,  46,  99, 111, 
-    108, 111, 114,  32,  42,  32, 
+     32,  32, 105, 102,  40,  32, 
     100, 111, 116,  40,  32, 105, 
     110, 112, 117, 116,  46, 110, 
     111, 114, 109,  97, 108,  44, 
@@ -4705,411 +4598,433 @@ const BYTE UIPixelShader[] =
     116, 115,  91,  32, 106,  32, 
      93,  46, 100, 105, 114, 101, 
      99, 116, 105, 111, 110,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32, 125,  13,  10,  32, 
-     32,  32,  32, 102, 111, 114, 
-     40,  32, 105, 110, 116,  32, 
-    105,  32,  61,  32,  48,  59, 
-     32, 105,  32,  60,  32, 112, 
-    111, 105, 110, 116,  76, 105, 
-    103, 104, 116,  67, 111, 117, 
-    110, 116,  59,  32, 105,  43, 
-     43,  32,  41,  13,  10,  32, 
-     32,  32,  32, 123,  13,  10, 
+     41,  32,  60,  32,  48,  32, 
+     41,  13,  10,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  51,  32, 108, 105, 103, 
-    104, 116,  68, 105, 114,  32, 
-     61,  32, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-    115,  91,  32, 105,  32,  93, 
-     46, 112, 111, 115, 105, 116, 
-    105, 111, 110,  32,  45,  32, 
-    105, 110, 112, 117, 116,  46, 
-    119, 111, 114, 108, 100,  80, 
-    111, 115,  46, 120, 121, 122, 
-     59,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32, 102, 
-     97,  99, 116, 111, 114,  59, 
+     32,  32,  32,  99, 111, 110, 
+    116, 105, 110, 117, 101,  59, 
      13,  10,  32,  32,  32,  32, 
-     32,  32,  32,  32, 105, 102, 
-     40,  32, 108, 101, 110, 103, 
-    116, 104,  40,  32, 108, 105, 
-    103, 104, 116,  68, 105, 114, 
-     32,  41,  32,  60,  32,  49, 
-     32,  41,  13,  10,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32, 102,  97, 
-     99, 116, 111, 114,  32,  61, 
-     32,  49,  59,  13,  10,  32, 
+     32,  32,  32,  32, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116,  32,  43, 
+     61,  32, 100, 105, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116, 115,  91,  32, 106,  32, 
+     93,  46,  99, 111, 108, 111, 
+    114,  32,  42,  32, 100, 111, 
+    116,  40,  32, 105, 110, 112, 
+    117, 116,  46, 110, 111, 114, 
+    109,  97, 108,  44,  32,  45, 
+    100, 105, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116, 115, 
+     91,  32, 106,  32,  93,  46, 
+    100, 105, 114, 101,  99, 116, 
+    105, 111, 110,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+    125,  13,  10,  32,  32,  32, 
+     32, 102, 111, 114,  40,  32, 
+    105, 110, 116,  32, 105,  32, 
+     61,  32,  48,  59,  32, 105, 
+     32,  60,  32, 112, 111, 105, 
+    110, 116,  76, 105, 103, 104, 
+    116,  67, 111, 117, 110, 116, 
+     59,  32, 105,  43,  43,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32, 101, 108, 115, 101,  13, 
+    102, 108, 111,  97, 116,  51, 
+     32, 108, 105, 103, 104, 116, 
+     68, 105, 114,  32,  61,  32, 
+    112, 111, 105, 110, 116,  76, 
+    105, 103, 104, 116, 115,  91, 
+     32, 105,  32,  93,  46, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  45,  32, 105, 110, 
+    112, 117, 116,  46, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+     46, 120, 121, 122,  59,  13, 
      10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  32, 102,  97,  99, 
+    116, 111, 114,  59,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-     32, 102,  97,  99, 116, 111, 
-    114,  32,  61,  32, 112, 111, 
-    105, 110, 116,  76, 105, 103, 
-    104, 116, 115,  91,  32, 105, 
-     32,  93,  46, 114,  97, 100, 
-    105, 117, 115,  32,  47,  32, 
+     32,  32, 105, 102,  40,  32, 
     108, 101, 110, 103, 116, 104, 
      40,  32, 108, 105, 103, 104, 
     116,  68, 105, 114,  32,  41, 
+     32,  60,  32,  49,  32,  41, 
+     13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32, 102,  97,  99, 116, 
+    111, 114,  32,  61,  32,  49, 
      59,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 101, 
+    108, 115, 101,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  32, 102, 
-     32,  61,  32, 100, 111, 116, 
-     40,  32, 105, 110, 112, 117, 
-    116,  46, 110, 111, 114, 109, 
-     97, 108,  44,  32, 110, 111, 
-    114, 109,  97, 108, 105, 122, 
-    101,  40,  32, 108, 105, 103, 
-    104, 116,  68, 105, 114,  32, 
-     41,  32,  41,  59,  13,  10, 
+     97,  99, 116, 111, 114,  32, 
+     61,  32, 112, 111, 105, 110, 
+    116,  76, 105, 103, 104, 116, 
+    115,  91,  32, 105,  32,  93, 
+     46, 114,  97, 100, 105, 117, 
+    115,  32,  47,  32, 108, 101, 
+    110, 103, 116, 104,  40,  32, 
+    108, 105, 103, 104, 116,  68, 
+    105, 114,  32,  41,  59,  13, 
+     10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  32, 102,  32,  61, 
+     32, 100, 111, 116,  40,  32, 
+    105, 110, 112, 117, 116,  46, 
+    110, 111, 114, 109,  97, 108, 
+     44,  32, 110, 111, 114, 109, 
+     97, 108, 105, 122, 101,  40, 
+     32, 108, 105, 103, 104, 116, 
+     68, 105, 114,  32,  41,  32, 
+     41,  59,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 105, 102,  40,  32, 
-    102,  32,  62,  32,  48,  32, 
-     41,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 123, 
-     13,  10,  32,  32,  32,  32, 
+    105, 102,  40,  32, 102,  32, 
+     62,  32,  48,  32,  41,  13, 
+     10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 123,  13,  10, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  32,  43,  61,  32, 
-    112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116, 115,  91, 
-     32, 105,  32,  93,  46,  99, 
-    111, 108, 111, 114,  32,  42, 
-     32, 102,  32,  42,  32, 102, 
-     97,  99, 116, 111, 114,  59, 
-     13,  10,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 102,  32,  61,  32, 
-    100, 111, 116,  40,  32, 110, 
-    111, 114, 109,  97, 108, 105, 
-    122, 101,  40,  32, 114, 101, 
-    102, 108, 101,  99, 116,  40, 
-     32, 110, 111, 114, 109,  97, 
-    108, 105, 122, 101,  40,  32, 
-     45, 108, 105, 103, 104, 116, 
-     68, 105, 114,  32,  41,  44, 
-     32, 105, 110, 112, 117, 116, 
-     46, 110, 111, 114, 109,  97, 
-    108,  32,  41,  32,  41,  44, 
-     32, 110, 111, 114, 109,  97, 
-    108, 105, 122, 101,  40,  32, 
-    107,  80, 111, 115, 105, 116, 
-    105, 111, 110,  46, 120, 121, 
-    122,  32,  45,  32, 105, 110, 
-    112, 117, 116,  46, 119, 111, 
-    114, 108, 100,  80, 111, 115, 
-     46, 120, 121, 122,  32,  41, 
-     32,  41,  59,  13,  10,  32, 
+    100, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     32,  43,  61,  32, 112, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116, 115,  91,  32, 105, 
+     32,  93,  46,  99, 111, 108, 
+    111, 114,  32,  42,  32, 102, 
+     32,  42,  32, 102,  97,  99, 
+    116, 111, 114,  59,  13,  10, 
+     32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32, 105, 
-    102,  40,  32, 102,  32,  62, 
-     32,  48,  32,  41,  13,  10, 
+    102,  32,  61,  32, 100, 111, 
+    116,  40,  32, 110, 111, 114, 
+    109,  97, 108, 105, 122, 101, 
+     40,  32, 114, 101, 102, 108, 
+    101,  99, 116,  40,  32, 110, 
+    111, 114, 109,  97, 108, 105, 
+    122, 101,  40,  32,  45, 108, 
+    105, 103, 104, 116,  68, 105, 
+    114,  32,  41,  44,  32, 105, 
+    110, 112, 117, 116,  46, 110, 
+    111, 114, 109,  97, 108,  32, 
+     41,  32,  41,  44,  32, 110, 
+    111, 114, 109,  97, 108, 105, 
+    122, 101,  40,  32, 107,  80, 
+    111, 115, 105, 116, 105, 111, 
+    110,  46, 120, 121, 122,  32, 
+     45,  32, 105, 110, 112, 117, 
+    116,  46, 119, 111, 114, 108, 
+    100,  80, 111, 115,  46, 120, 
+    121, 122,  32,  41,  32,  41, 
+     59,  13,  10,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
+     32,  32,  32, 105, 102,  40, 
+     32, 102,  32,  62,  32,  48, 
+     32,  41,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32, 115, 112, 
-    101,  99, 117, 108,  97, 114, 
-     76, 105, 103, 104, 116,  32, 
-     43,  61,  32, 112, 111, 105, 
-    110, 116,  76, 105, 103, 104, 
-    116, 115,  91,  32, 105,  32, 
-     93,  46,  99, 111, 108, 111, 
-    114,  32,  42,  32, 102,  32, 
-     42,  32, 102,  97,  99, 116, 
-    111, 114,  59,  13,  10,  32, 
      32,  32,  32,  32,  32,  32, 
-     32, 125,  13,  10,  32,  32, 
-     32,  32, 125,  13,  10,  32, 
-     32,  32,  32,  47,  47, 105, 
-    102,  32,  40,  33,  40, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  46, 
-    120,  32,  62,  61,  32,  48, 
-     32,  38,  38,  32, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  46, 120, 
-     32,  60,  61,  32,  49,  41, 
-     41,  13,  10,  32,  32,  32, 
-     32,  47,  47,   9, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  46, 120, 
-     32,  61,  32,  48,  59,  13, 
-     10,  32,  32,  32,  32, 102, 
-    108, 111,  97, 116,  52,  32, 
-    109,  97, 116, 101, 114, 105, 
-     97, 108,  67, 111, 108, 111, 
-    114,  32,  61,  32, 115, 104, 
-     97, 100, 101, 114,  84, 101, 
-    120, 116, 117, 114, 101,  46, 
+     32,  32, 115, 112, 101,  99, 
+    117, 108,  97, 114,  76, 105, 
+    103, 104, 116,  32,  43,  61, 
+     32, 112, 111, 105, 110, 116, 
+     76, 105, 103, 104, 116, 115, 
+     91,  32, 105,  32,  93,  46, 
+     99, 111, 108, 111, 114,  32, 
+     42,  32, 102,  32,  42,  32, 
+    102,  97,  99, 116, 111, 114, 
+     59,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 125, 
+     13,  10,  32,  32,  32,  32, 
+    125,  13,  10,  32,  32,  32, 
+     32,  47,  47, 105, 102,  32, 
+     40,  33,  40, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  46, 120,  32, 
+     62,  61,  32,  48,  32,  38, 
+     38,  32, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  46, 120,  32,  60, 
+     61,  32,  49,  41,  41,  13, 
+     10,  32,  32,  32,  32,  47, 
+     47,   9, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  46, 120,  32,  61, 
+     32,  48,  59,  13,  10,  32, 
+     32,  32,  32, 102, 108, 111, 
+     97, 116,  52,  32, 109,  97, 
+    116, 101, 114, 105,  97, 108, 
+     67, 111, 108, 111, 114,  32, 
+     61,  32, 115, 104,  97, 100, 
+    101, 114,  84, 101, 120, 116, 
+    117, 114, 101,  46,  83,  97, 
+    109, 112, 108, 101,  40,  32, 
      83,  97, 109, 112, 108, 101, 
-     40,  32,  83,  97, 109, 112, 
-    108, 101,  84, 121, 112, 101, 
-     44,  32, 105, 110, 112, 117, 
-    116,  46, 116, 101, 120,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32, 105, 102,  40,  32, 
-    101, 102, 102, 101,  99, 116, 
-     69, 110,  97,  98, 108, 101, 
-    100,  32,  41,  13,  10,  32, 
-     32,  32,  32, 123,  13,  10, 
+     84, 121, 112, 101,  44,  32, 
+    105, 110, 112, 117, 116,  46, 
+    116, 101, 120,  32,  41,  59, 
+     13,  10,  32,  32,  32,  32, 
+    105, 102,  40,  32, 101, 102, 
+    102, 101,  99, 116,  69, 110, 
+     97,  98, 108, 101, 100,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32, 102, 108, 111,  97, 
-    116,  32, 100, 105, 115, 116, 
-     32,  61,  32, 115, 113, 114, 
-    116,  40,  32,  40, 105, 110, 
-    112, 117, 116,  46, 116, 101, 
-    120,  46, 120,  32,  45,  32, 
-     48,  46,  53, 102,  41,  32, 
-     42,  32,  40, 105, 110, 112, 
-    117, 116,  46, 116, 101, 120, 
-     46, 120,  32,  45,  32,  48, 
-     46,  53, 102,  41,  32,  43, 
+    102, 108, 111,  97, 116,  32, 
+    100, 105, 115, 116,  32,  61, 
+     32, 115, 113, 114, 116,  40, 
      32,  40, 105, 110, 112, 117, 
     116,  46, 116, 101, 120,  46, 
-    121,  32,  45,  32,  48,  46, 
+    120,  32,  45,  32,  48,  46, 
      53, 102,  41,  32,  42,  32, 
      40, 105, 110, 112, 117, 116, 
-     46, 116, 101, 120,  46, 121, 
+     46, 116, 101, 120,  46, 120, 
      32,  45,  32,  48,  46,  53, 
-    102,  41,  32,  41,  32,  47, 
-     32, 115, 113, 114, 116,  40, 
-     32,  48,  46,  53, 102,  32, 
-     41,  59,  13,  10,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-    105, 102,  40,  32, 100, 105, 
-    115, 116,  32,  60,  32, 101, 
-    102, 102, 101,  99, 116,  80, 
-    101, 114,  99, 101, 110, 116, 
-     97, 103, 101,  32,  41,  13, 
-     10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 123,  13,  10, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  32, 
-     97, 108, 112, 104,  97,  77, 
-    117, 108, 116, 105, 112, 108, 
-    105, 101, 114,  32,  61,  32, 
-     40, 101, 102, 102, 101,  99, 
-    116,  80, 101, 114,  99, 101, 
-    110, 116,  97, 103, 101,  32, 
-     45,  32, 100, 105, 115, 116, 
-     41,  32,  47,  32,  48,  46, 
-     50, 102,  59,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32, 105, 
-    102,  40,  32,  97, 108, 112, 
-    104,  97,  77, 117, 108, 116, 
-    105, 112, 108, 105, 101, 114, 
-     32,  62,  32,  49,  32,  41, 
+    102,  41,  32,  43,  32,  40, 
+    105, 110, 112, 117, 116,  46, 
+    116, 101, 120,  46, 121,  32, 
+     45,  32,  48,  46,  53, 102, 
+     41,  32,  42,  32,  40, 105, 
+    110, 112, 117, 116,  46, 116, 
+    101, 120,  46, 121,  32,  45, 
+     32,  48,  46,  53, 102,  41, 
+     32,  41,  32,  47,  32, 115, 
+    113, 114, 116,  40,  32,  48, 
+     46,  53, 102,  32,  41,  59, 
      13,  10,  32,  32,  32,  32, 
+     32,  32,  32,  32, 105, 102, 
+     40,  32, 100, 105, 115, 116, 
+     32,  60,  32, 101, 102, 102, 
+    101,  99, 116,  80, 101, 114, 
+     99, 101, 110, 116,  97, 103, 
+    101,  32,  41,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32, 123,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  32,  97, 108, 
+    112, 104,  97,  77, 117, 108, 
+    116, 105, 112, 108, 105, 101, 
+    114,  32,  61,  32,  40, 101, 
+    102, 102, 101,  99, 116,  80, 
+    101, 114,  99, 101, 110, 116, 
+     97, 103, 101,  32,  45,  32, 
+    100, 105, 115, 116,  41,  32, 
+     47,  32,  48,  46,  50, 102, 
+     59,  13,  10,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     97, 108, 112, 104,  97,  77, 
-    117, 108, 116, 105, 112, 108, 
-    105, 101, 114,  32,  61,  32, 
-     49,  46, 102,  59,  13,  10, 
+     32,  32,  32, 105, 102,  40, 
+     32,  97, 108, 112, 104,  97, 
+     77, 117, 108, 116, 105, 112, 
+    108, 105, 101, 114,  32,  62, 
+     32,  49,  32,  41,  13,  10, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-    102, 108, 111,  97, 116,  52, 
-     32, 101, 102, 102, 101,  99, 
-    116,  67, 111, 108, 111, 114, 
-     32,  61,  32,  97, 100, 100, 
-    105, 116, 105, 111, 110,  97, 
-    108,  84, 101, 120, 116, 117, 
-    114, 101,  46,  83,  97, 109, 
-    112, 108, 101,  40,  32,  83, 
-     97, 109, 112, 108, 101,  84, 
-    121, 112, 101,  44,  32, 105, 
-    110, 112, 117, 116,  46, 116, 
-    101, 120,  32,  41,  59,  13, 
-     10,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  97, 108, 
+    112, 104,  97,  77, 117, 108, 
+    116, 105, 112, 108, 105, 101, 
+    114,  32,  61,  32,  49,  46, 
+    102,  59,  13,  10,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32, 109,  97, 116, 101, 114, 
-    105,  97, 108,  67, 111, 108, 
-    111, 114,  32,  61,  32, 101, 
+     32,  32,  32,  32, 102, 108, 
+    111,  97, 116,  52,  32, 101, 
     102, 102, 101,  99, 116,  67, 
-    111, 108, 111, 114,  32,  42, 
-     32,  40, 101, 102, 102, 101, 
+    111, 108, 111, 114,  32,  61, 
+     32,  97, 100, 100, 105, 116, 
+    105, 111, 110,  97, 108,  84, 
+    101, 120, 116, 117, 114, 101, 
+     46,  83,  97, 109, 112, 108, 
+    101,  40,  32,  83,  97, 109, 
+    112, 108, 101,  84, 121, 112, 
+    101,  44,  32, 105, 110, 112, 
+    117, 116,  46, 116, 101, 120, 
+     32,  41,  59,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32, 109, 
+     97, 116, 101, 114, 105,  97, 
+    108,  67, 111, 108, 111, 114, 
+     32,  61,  32, 101, 102, 102, 
+    101,  99, 116,  67, 111, 108, 
+    111, 114,  32,  42,  32,  40, 
+    101, 102, 102, 101,  99, 116, 
+     67, 111, 108, 111, 114,  46, 
+     97,  32,  42,  32,  97, 108, 
+    112, 104,  97,  77, 117, 108, 
+    116, 105, 112, 108, 105, 101, 
+    114,  41,  32,  43,  32, 109, 
+     97, 116, 101, 114, 105,  97, 
+    108,  67, 111, 108, 111, 114, 
+     32,  42,  32,  40,  49,  32, 
+     45,  32, 101, 102, 102, 101, 
      99, 116,  67, 111, 108, 111, 
     114,  46,  97,  32,  42,  32, 
      97, 108, 112, 104,  97,  77, 
     117, 108, 116, 105, 112, 108, 
-    105, 101, 114,  41,  32,  43, 
-     32, 109,  97, 116, 101, 114, 
-    105,  97, 108,  67, 111, 108, 
-    111, 114,  32,  42,  32,  40, 
-     49,  32,  45,  32, 101, 102, 
-    102, 101,  99, 116,  67, 111, 
-    108, 111, 114,  46,  97,  32, 
-     42,  32,  97, 108, 112, 104, 
-     97,  77, 117, 108, 116, 105, 
-    112, 108, 105, 101, 114,  41, 
-     59,  13,  10,  32,  32,  32, 
-     32,  32,  32,  32,  32, 125, 
-     13,  10,  32,  32,  32,  32, 
-    125,  13,  10,  32,  32,  32, 
-     32, 102, 108, 111,  97, 116, 
-     52,  32, 116, 101, 120, 116, 
-    117, 114, 101,  67, 111, 108, 
-    111, 114,  32,  61,  32, 115, 
-     97, 116, 117, 114,  97, 116, 
-    101,  40,  32,  40, 109,  97, 
-    116, 101, 114, 105,  97, 108, 
-     67, 111, 108, 111, 114,  32, 
-     42,  32,  97, 109,  98, 105, 
-    101, 110, 116,  70,  97,  99, 
-    116, 111, 114,  41,  32,  43, 
-     32,  40, 102, 108, 111,  97, 
-    116,  52,  40, 100, 105, 102, 
-    102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  44, 
-     32, 100, 105, 102, 102, 117, 
+    105, 101, 114,  41,  59,  13, 
+     10,  32,  32,  32,  32,  32, 
+     32,  32,  32, 125,  13,  10, 
+     32,  32,  32,  32, 125,  13, 
+     10,  32,  32,  32,  32, 102, 
+    108, 111,  97, 116,  52,  32, 
+    116, 101, 120, 116, 117, 114, 
+    101,  67, 111, 108, 111, 114, 
+     32,  61,  32, 115,  97, 116, 
+    117, 114,  97, 116, 101,  40, 
+     32,  40, 109,  97, 116, 101, 
+    114, 105,  97, 108,  67, 111, 
+    108, 111, 114,  32,  42,  32, 
+     97, 109,  98, 105, 101, 110, 
+    116,  70,  97,  99, 116, 111, 
+    114,  41,  32,  43,  32,  40, 
+    102, 108, 111,  97, 116,  52, 
+     40, 100, 105, 102, 102, 117, 
     115, 101,  76, 105, 103, 104, 
-    116,  46, 121,  44,  32, 100, 
+    116,  46, 120,  44,  32, 100, 
     105, 102, 102, 117, 115, 101, 
      76, 105, 103, 104, 116,  46, 
-    122,  44,  32,  48,  41,  32, 
-     42,  32, 100, 105, 102, 102, 
-    117, 115,  70,  97,  99, 116, 
-    111, 114,  41,  32,  43,  32, 
-     40, 102, 108, 111,  97, 116, 
-     52,  40, 115, 112, 101,  99, 
-    117, 108,  97, 114,  76, 105, 
-    103, 104, 116,  46, 120,  44, 
-     32, 115, 112, 101,  99, 117, 
-    108,  97, 114,  76, 105, 103, 
-    104, 116,  46, 121,  44,  32, 
+    121,  44,  32, 100, 105, 102, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116,  46, 122,  44, 
+     32,  48,  41,  32,  42,  32, 
+    100, 105, 102, 102, 117, 115, 
+     70,  97,  99, 116, 111, 114, 
+     41,  32,  43,  32,  40, 102, 
+    108, 111,  97, 116,  52,  40, 
     115, 112, 101,  99, 117, 108, 
      97, 114,  76, 105, 103, 104, 
-    116,  46, 122,  44,  32,  48, 
-     41,  32,  42,  32, 115, 112, 
+    116,  46, 120,  44,  32, 115, 
+    112, 101,  99, 117, 108,  97, 
+    114,  76, 105, 103, 104, 116, 
+     46, 121,  44,  32, 115, 112, 
     101,  99, 117, 108,  97, 114, 
-     70,  97,  99, 116, 111, 114, 
-     41,  32,  41,  59,  13,  10, 
-     32,  32,  32,  32, 116, 101, 
-    120, 116, 117, 114, 101,  67, 
-    111, 108, 111, 114,  46,  97, 
-     32,  61,  32, 109,  97, 116, 
-    101, 114, 105,  97, 108,  67, 
-    111, 108, 111, 114,  46,  97, 
-     59,  13,  10,  32,  32,  32, 
-     32, 105, 102,  40,  32, 105, 
-    115, 110,  97, 110,  40,  32, 
-    100, 105, 102, 102, 117, 115, 
-    101,  76, 105, 103, 104, 116, 
-     46, 120,  32,  42,  32, 100, 
-    105, 102, 102, 117, 115,  70, 
-     97,  99, 116, 111, 114,  32, 
-     41,  32,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32, 116, 101, 120, 116, 117, 
-    114, 101,  67, 111, 108, 111, 
-    114,  32,  61,  32, 109,  97, 
-    116, 101, 114, 105,  97, 108, 
-     67, 111, 108, 111, 114,  59, 
-     13,  10,  32,  32,  32,  32, 
-    114, 101, 116, 117, 114, 110, 
-     32, 116, 101, 120, 116, 117, 
-    114, 101,  67, 111, 108, 111, 
-    114,  59,  13,  10,  32,  32, 
-     32,  32,  47,  47, 114, 101, 
+     76, 105, 103, 104, 116,  46, 
+    122,  44,  32,  48,  41,  32, 
+     42,  32, 115, 112, 101,  99, 
+    117, 108,  97, 114,  70,  97, 
+     99, 116, 111, 114,  41,  32, 
+     41,  59,  13,  10,  32,  32, 
+     32,  32, 116, 101, 120, 116, 
+    117, 114, 101,  67, 111, 108, 
+    111, 114,  46,  97,  32,  61, 
+     32, 109,  97, 116, 101, 114, 
+    105,  97, 108,  67, 111, 108, 
+    111, 114,  46,  97,  59,  13, 
+     10,  32,  32,  32,  32, 105, 
+    102,  40,  32, 105, 115, 110, 
+     97, 110,  40,  32, 100, 105, 
+    102, 102, 117, 115, 101,  76, 
+    105, 103, 104, 116,  46, 120, 
+     32,  42,  32, 100, 105, 102, 
+    102, 117, 115,  70,  97,  99, 
+    116, 111, 114,  32,  41,  32, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 116, 
+    101, 120, 116, 117, 114, 101, 
+     67, 111, 108, 111, 114,  32, 
+     61,  32, 109,  97, 116, 101, 
+    114, 105,  97, 108,  67, 111, 
+    108, 111, 114,  59,  13,  10, 
+     32,  32,  32,  32, 114, 101, 
     116, 117, 114, 110,  32, 116, 
     101, 120, 116, 117, 114, 101, 
      67, 111, 108, 111, 114,  59, 
      13,  10,  32,  32,  32,  32, 
-     47,  47, 105, 102,  32,  40, 
-    100, 105, 102, 102, 117, 115, 
-     70,  97,  99, 116, 111, 114, 
-     32,  61,  61,  32,  48,  41, 
-     13,  10,  32,  32,  32,  32, 
-     47,  47,   9, 114, 101, 116, 
-    117, 114, 110,  32, 102, 108, 
-    111,  97, 116,  52,  40,  49, 
-     44,  32,  49,  44,  32,  48, 
-     44,  32,  49,  41,  59,  13, 
-     10,  32,  32,  32,  32,  47, 
-     42, 105, 102,  32,  40, 105, 
-    115, 110,  97, 110,  40, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  46, 
-    120,  41,  32, 124, 124,  32, 
-    105, 115, 110,  97, 110,  40, 
-    100, 105, 102, 102, 117, 115, 
-     70,  97,  99, 116, 111, 114, 
-     41,  32, 124, 124,  32, 105, 
-    115, 105, 110, 102,  40, 100, 
-    105, 102, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116,  46, 
-    120,  41,  32, 124, 124,  32, 
-    105, 115, 105, 110, 102,  40, 
-     45, 100, 105, 102, 102, 117, 
-    115, 101,  76, 105, 103, 104, 
-    116,  46, 120,  41,  41,  13, 
-     10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 114, 101, 116, 
-    117, 114, 110,  32, 102, 108, 
-    111,  97, 116,  52,  40,  48, 
-     44,  32,  49,  44,  32,  49, 
-     44,  32,  49,  41,  59,  13, 
-     10,  32,  32,  32,  32, 105, 
+     47,  47, 114, 101, 116, 117, 
+    114, 110,  32, 116, 101, 120, 
+    116, 117, 114, 101,  67, 111, 
+    108, 111, 114,  59,  13,  10, 
+     32,  32,  32,  32,  47,  47, 
+    105, 102,  32,  40, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  32,  61, 
+     61,  32,  48,  41,  13,  10, 
+     32,  32,  32,  32,  47,  47, 
+      9, 114, 101, 116, 117, 114, 
+    110,  32, 102, 108, 111,  97, 
+    116,  52,  40,  49,  44,  32, 
+     49,  44,  32,  48,  44,  32, 
+     49,  41,  59,  13,  10,  32, 
+     32,  32,  32,  47,  42, 105, 
     102,  32,  40, 105, 115, 110, 
      97, 110,  40, 100, 105, 102, 
     102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  32, 
-     45,  32, 100, 105, 102, 102, 
-    117, 115, 101,  76, 105, 103, 
-    104, 116,  46, 120,  41,  32, 
-     38,  38,  32, 105, 115, 110, 
-     97, 110,  40, 100, 105, 102, 
+    103, 104, 116,  46, 120,  41, 
+     32, 124, 124,  32, 105, 115, 
+    110,  97, 110,  40, 100, 105, 
+    102, 102, 117, 115,  70,  97, 
+     99, 116, 111, 114,  41,  32, 
+    124, 124,  32, 105, 115, 105, 
+    110, 102,  40, 100, 105, 102, 
     102, 117, 115, 101,  76, 105, 
-    103, 104, 116,  46, 120,  32, 
-     42,  32, 100, 105, 102, 102, 
-    117, 115,  70,  97,  99, 116, 
-    111, 114,  41,  32,  41,  13, 
-     10,  32,  32,  32,  32,  32, 
-     32,  32,  32, 114, 101, 116, 
-    117, 114, 110,  32, 102, 108, 
-    111,  97, 116,  52,  40,  49, 
-     44,  32,  49,  44,  32,  49, 
-     44,  32,  49,  41,  59,  13, 
-     10,  32,  32,  32,  32, 105, 
-    102,  32,  40,  40, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  46, 120, 
-     32,  42,  32, 100, 105, 102, 
-    102, 117, 115,  70,  97,  99, 
-    116, 111, 114,  41,  32,  33, 
-     61,  32,  48,  32,  38,  38, 
-     32,  40, 100, 105, 102, 102, 
+    103, 104, 116,  46, 120,  41, 
+     32, 124, 124,  32, 105, 115, 
+    105, 110, 102,  40,  45, 100, 
+    105, 102, 102, 117, 115, 101, 
+     76, 105, 103, 104, 116,  46, 
+    120,  41,  41,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32, 114, 101, 116, 117, 114, 
+    110,  32, 102, 108, 111,  97, 
+    116,  52,  40,  48,  44,  32, 
+     49,  44,  32,  49,  44,  32, 
+     49,  41,  59,  13,  10,  32, 
+     32,  32,  32, 105, 102,  32, 
+     40, 105, 115, 110,  97, 110, 
+     40, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  46, 120,  32,  45,  32, 
+    100, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     46, 120,  41,  32,  38,  38, 
+     32, 105, 115, 110,  97, 110, 
+     40, 100, 105, 102, 102, 117, 
+    115, 101,  76, 105, 103, 104, 
+    116,  46, 120,  32,  42,  32, 
+    100, 105, 102, 102, 117, 115, 
+     70,  97,  99, 116, 111, 114, 
+     41,  32,  41,  13,  10,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32, 114, 101, 116, 117, 114, 
+    110,  32, 102, 108, 111,  97, 
+    116,  52,  40,  49,  44,  32, 
+     49,  44,  32,  49,  44,  32, 
+     49,  41,  59,  13,  10,  32, 
+     32,  32,  32, 105, 102,  32, 
+     40,  40, 100, 105, 102, 102, 
     117, 115, 101,  76, 105, 103, 
     104, 116,  46, 120,  32,  42, 
      32, 100, 105, 102, 102, 117, 
     115,  70,  97,  99, 116, 111, 
     114,  41,  32,  33,  61,  32, 
-     45,  48,  41,  13,  10,  32, 
-     32,  32,  32,  32,  32,  32, 
+     48,  32,  38,  38,  32,  40, 
+    100, 105, 102, 102, 117, 115, 
+    101,  76, 105, 103, 104, 116, 
+     46, 120,  32,  42,  32, 100, 
+    105, 102, 102, 117, 115,  70, 
+     97,  99, 116, 111, 114,  41, 
+     32,  33,  61,  32,  45,  48, 
+     41,  13,  10,  32,  32,  32, 
+     32,  32,  32,  32,  32, 114, 
+    101, 116, 117, 114, 110,  32, 
+    102, 108, 111,  97, 116,  52, 
+     40,  48,  44,  32,  48,  44, 
+     32,  49,  44,  32,  49,  41, 
+     59,  13,  10,  32,  32,  32, 
      32, 114, 101, 116, 117, 114, 
     110,  32, 102, 108, 111,  97, 
     116,  52,  40,  48,  44,  32, 
-     48,  44,  32,  49,  44,  32, 
-     49,  41,  59,  13,  10,  32, 
-     32,  32,  32, 114, 101, 116, 
-    117, 114, 110,  32, 102, 108, 
-    111,  97, 116,  52,  40,  48, 
-     44,  32,  49,  44,  32,  48, 
-     44,  32,  49,  41,  59,  42, 
-     47,  13,  10, 125,   0,   7, 
+     49,  44,  32,  48,  44,  32, 
+     49,  41,  59,  42,  47,  13, 
+     10, 125,   0,   7,   0,   0, 
+      0,   0,   0,   0,   0,  84, 
       0,   0,   0,   0,   0,   0, 
-      0,  84,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,  85, 
+      0,   0,   0, 168,   0,   0, 
+      0,   1,   0,   0,   0,   4, 
       0,   0,   0,   0,   0,   0, 
-      0,  85,   0,   0,   0, 168, 
-      0,   0,   0,   1,   0,   0, 
-      0,   4,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5132,14 +5047,13 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  68,  51, 
-     68,  83,  72,  68,  82,   0, 
-     16,  16,   0,   0,   0,   0, 
+      0,   0,  68,  51,  68,  83, 
+     72,  68,  82,   0,  16,  16, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
-      0,  96,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  32,   0,   0,  96, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5218,35 +5132,36 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,  26,   9, 
-     47, 241, 112,   0,   0,   0, 
-     60,   2,   0,   0, 209,   1, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,  26,   9,  47, 241, 
+    112,   0,   0,   0,  60,   2, 
+      0,   0, 209,   1,   0,   0, 
+      1,   0,   0,   0,  37,   0, 
       0,   0,   1,   0,   0,   0, 
-     37,   0,   0,   0,   1,   0, 
-      0,   0,  29,   1,   0,   0, 
-      1,   0,   0,   0,  65,   1, 
+     29,   1,   0,   0,   1,   0, 
+      0,   0,  65,   1,   0,   0, 
+      1,   0,   0,   0, 141,   1, 
       0,   0,   1,   0,   0,   0, 
-    141,   1,   0,   0,   1,   0, 
-      0,   0, 245,   0,   0,   0, 
-      1,   0,   0,   0, 209,   0, 
+    245,   0,   0,   0,   1,   0, 
+      0,   0, 209,   0,   0,   0, 
+      1,   0,   0,   0, 173,   0, 
       0,   0,   1,   0,   0,   0, 
-    173,   0,   0,   0,   1,   0, 
-      0,   0, 177,   1,   0,   0, 
-      1,   0,   0,   0, 137,   0, 
+    177,   1,   0,   0,   1,   0, 
+      0,   0, 137,   0,   0,   0, 
+      1,   0,   0,   0, 105,   0, 
       0,   0,   1,   0,   0,   0, 
-    105,   0,   0,   0,   1,   0, 
-      0,   0, 101,   1,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
+    101,   1,   0,   0,   1,   0, 
       0,   0,   1,   0,   0,   0, 
-     73,   0,   0,   0,   1,   0, 
-      0,   0,   8,   0,   0,   0, 
+      1,   0,   0,   0,  73,   0, 
+      0,   0,   1,   0,   0,   0, 
+      8,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   1, 
       0,   0,   0,   0,   0,   0, 
-      0,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5257,26 +5172,26 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  32,   0,   0,   0, 
-      0,   0,   0,   0,   0, 128, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0, 128,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0, 128, 
+      0,   0,   0, 128,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   2,   0, 
       0,   0,   0,   0,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   2,   0, 
+      0,   0,   2,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  64,   0,   0, 
+      0,  64,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5292,8 +5207,8 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  16,   0, 
       0,   0,   0,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5303,38 +5218,38 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
+      0,   0,  32,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   2, 
       0,   0,   0,   0,   0,   0, 
-      0,   2,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 128,   0, 
+      0,   0, 128,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,  16, 
       0,   0,   0,   0,   0,   0, 
-      0,  16,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0, 128, 
+      0,   0,   0, 128,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  12,   0, 
+      0,   0,  24,   0,   0,   0, 
+     36,   0,   0,   0,  48,   0, 
+      0,   0,  60,   0,   0,   0, 
+     72,   0,   0,   0,  84,   0, 
+      0,   0,  96,   0,   0,   0, 
+    108,   0,   0,   0, 120,   0, 
+      0,   0, 132,   0,   0,   0, 
+    144,   0,   0,   0, 156,   0, 
       0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,  24,   0, 
-      0,   0,  36,   0,   0,   0, 
-     48,   0,   0,   0,  60,   0, 
-      0,   0,  72,   0,   0,   0, 
-     84,   0,   0,   0,  96,   0, 
-      0,   0, 108,   0,   0,   0, 
-    120,   0,   0,   0, 132,   0, 
-      0,   0, 144,   0,   0,   0, 
-    156,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5388,100 +5303,98 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  34,   0, 
-     37,  17,   0,   0,   0,   0, 
-    140,   0,   0,   0,   1,   0, 
-     84, 101, 120, 116, 117, 114, 
-    101,  80, 105, 120, 101, 108, 
-     83, 104,  97, 100, 101, 114, 
-      0,   0,   0,   0,  34,   0, 
-     81,  17,  10,  16,   0,   0, 
-      7,   0, 255, 255, 255, 255, 
-      0,   0, 255, 255, 255, 255, 
-    115, 104,  97, 100, 101, 114, 
-     84, 101, 120, 116, 117, 114, 
-    101,   0,   0,   0,  30,   0, 
-     81,  17,  13,  16,   0,   0, 
-      6,   0, 255, 255, 255, 255, 
-    255, 255,   0,   0, 255, 255, 
-     83,  97, 109, 112, 108, 101, 
-     84, 121, 112, 101,   0,   0, 
-     30,   0,  81,  17,  14,  16, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 107,  80, 111, 115, 
-    105, 116, 105, 111, 110,   0, 
-      0,   0,  34,   0,  81,  17, 
-     16,  16,   0,   0,   8,   0, 
-      1,   0,   0,   0, 255, 255, 
-    255, 255, 255, 255,  97, 109, 
-     98, 105, 101, 110, 116,  70, 
-     97,  99, 116, 111, 114,   0, 
+      0,   0,  34,   0,  37,  17, 
+      0,   0,   0,   0, 140,   0, 
+      0,   0,   1,   0,  84, 101, 
+    120, 116, 117, 114, 101,  80, 
+    105, 120, 101, 108,  83, 104, 
+     97, 100, 101, 114,   0,   0, 
       0,   0,  34,   0,  81,  17, 
-     16,  16,   0,   0,   8,   0, 
-      1,   0,   4,   0, 255, 255, 
-    255, 255, 255, 255, 100, 105, 
-    102, 102, 117, 115,  70,  97, 
+     10,  16,   0,   0,   7,   0, 
+    255, 255, 255, 255,   0,   0, 
+    255, 255, 255, 255, 115, 104, 
+     97, 100, 101, 114,  84, 101, 
+    120, 116, 117, 114, 101,   0, 
+      0,   0,  30,   0,  81,  17, 
+     13,  16,   0,   0,   6,   0, 
+    255, 255, 255, 255, 255, 255, 
+      0,   0, 255, 255,  83,  97, 
+    109, 112, 108, 101,  84, 121, 
+    112, 101,   0,   0,  30,   0, 
+     81,  17,  14,  16,   0,   0, 
+      8,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255, 255, 255, 
+    107,  80, 111, 115, 105, 116, 
+    105, 111, 110,   0,   0,   0, 
+     34,   0,  81,  17,  16,  16, 
+      0,   0,   8,   0,   1,   0, 
+      0,   0, 255, 255, 255, 255, 
+    255, 255,  97, 109,  98, 105, 
+    101, 110, 116,  70,  97,  99, 
+    116, 111, 114,   0,   0,   0, 
+     34,   0,  81,  17,  16,  16, 
+      0,   0,   8,   0,   1,   0, 
+      4,   0, 255, 255, 255, 255, 
+    255, 255, 100, 105, 102, 102, 
+    117, 115,  70,  97,  99, 116, 
+    111, 114,   0,   0,   0,   0, 
+     34,   0,  81,  17,  16,  16, 
+      0,   0,   8,   0,   1,   0, 
+      8,   0, 255, 255, 255, 255, 
+    255, 255, 115, 112, 101,  99, 
+    117, 108,  97, 114,  70,  97, 
      99, 116, 111, 114,   0,   0, 
-      0,   0,  34,   0,  81,  17, 
-     16,  16,   0,   0,   8,   0, 
-      1,   0,   8,   0, 255, 255, 
-    255, 255, 255, 255, 115, 112, 
-    101,  99, 117, 108,  97, 114, 
-     70,  97,  99, 116, 111, 114, 
-      0,   0,  38,   0,  81,  17, 
-     18,  16,   0,   0,   8,   0, 
-      2,   0,   0,   0, 255, 255, 
-    255, 255, 255, 255, 100, 105, 
-    102, 102, 117, 115, 101,  76, 
-    105, 103, 104, 116,  67, 111, 
-    117, 110, 116,   0,   0,   0, 
-     34,   0,  81,  17,  18,  16, 
+     38,   0,  81,  17,  18,  16, 
       0,   0,   8,   0,   2,   0, 
-      4,   0, 255, 255, 255, 255, 
-    255, 255, 112, 111, 105, 110, 
-    116,  76, 105, 103, 104, 116, 
-     67, 111, 117, 110, 116,   0, 
-     34,   0,  81,  17,  20,  16, 
-      0,   0,   8,   0,   3,   0, 
       0,   0, 255, 255, 255, 255, 
-    255, 255, 101, 102, 102, 101, 
-     99, 116,  69, 110,  97,  98, 
-    108, 101, 100,   0,   0,   0, 
-     38,   0,  81,  17,  16,  16, 
-      0,   0,   8,   0,   3,   0, 
-      4,   0, 255, 255, 255, 255, 
-    255, 255, 101, 102, 102, 101, 
-     99, 116,  80, 101, 114,  99, 
-    101, 110, 116,  97, 103, 101, 
-      0,   0,   0,   0,  34,   0, 
-     81,  17,  25,  16,   0,   0, 
-      7,   0, 255, 255, 255, 255, 
-      1,   0, 255, 255, 255, 255, 
-    100, 105, 102, 117, 115, 101, 
-     76, 105, 103, 104, 116, 115, 
-      0,   0,   0,   0,  30,   0, 
-     81,  17,  30,  16,   0,   0, 
-      7,   0, 255, 255, 255, 255, 
-      2,   0, 255, 255, 255, 255, 
+    255, 255, 100, 105, 102, 102, 
+    117, 115, 101,  76, 105, 103, 
+    104, 116,  67, 111, 117, 110, 
+    116,   0,   0,   0,  34,   0, 
+     81,  17,  18,  16,   0,   0, 
+      8,   0,   2,   0,   4,   0, 
+    255, 255, 255, 255, 255, 255, 
     112, 111, 105, 110, 116,  76, 
-    105, 103, 104, 116, 115,   0, 
-     38,   0,  81,  17,  33,  16, 
-      0,   0,   7,   0, 255, 255, 
-    255, 255,   3,   0, 255, 255, 
-    255, 255,  97, 100, 100, 105, 
-    116, 105, 111, 110,  97, 108, 
-     84, 101, 120, 116, 117, 114, 
-    101,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
+    105, 103, 104, 116,  67, 111, 
+    117, 110, 116,   0,  34,   0, 
+     81,  17,  20,  16,   0,   0, 
+      8,   0,   3,   0,   0,   0, 
+    255, 255, 255, 255, 255, 255, 
+    101, 102, 102, 101,  99, 116, 
+     69, 110,  97,  98, 108, 101, 
+    100,   0,   0,   0,  38,   0, 
+     81,  17,  16,  16,   0,   0, 
+      8,   0,   3,   0,   4,   0, 
+    255, 255, 255, 255, 255, 255, 
+    101, 102, 102, 101,  99, 116, 
+     80, 101, 114,  99, 101, 110, 
+    116,  97, 103, 101,   0,   0, 
+      0,   0,  34,   0,  81,  17, 
+     25,  16,   0,   0,   7,   0, 
+    255, 255, 255, 255,   1,   0, 
+    255, 255, 255, 255, 100, 105, 
+    102, 117, 115, 101,  76, 105, 
+    103, 104, 116, 115,   0,   0, 
+      0,   0,  30,   0,  81,  17, 
+     30,  16,   0,   0,   7,   0, 
+    255, 255, 255, 255,   2,   0, 
+    255, 255, 255, 255, 112, 111, 
+    105, 110, 116,  76, 105, 103, 
+    104, 116, 115,   0,  38,   0, 
+     81,  17,  33,  16,   0,   0, 
+      7,   0, 255, 255, 255, 255, 
+      3,   0, 255, 255, 255, 255, 
+     97, 100, 100, 105, 116, 105, 
+    111, 110,  97, 108,  84, 101, 
+    120, 116, 117, 114, 101,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  16,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,  26,   9,  47, 241, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+     26,   9,  47, 241,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5559,69 +5472,70 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-    119,   9,  49,   1,   1,   0, 
-      0,   0,  15,   0,  38, 142, 
-     16,   0, 116, 129,  17,   0, 
-    100,   0,  88,   0,   0,   0, 
-     32,   0,   0,   0,  44,   0, 
-      0,   0,  96,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  24,   0,   0,   0, 
-     25,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
+    255, 255, 255, 255, 119,   9, 
+     49,   1,   1,   0,   0,   0, 
+     13,   0,  20, 142,  14,   0, 
+     20, 107,  15,   0,   1,   0, 
+     88,   0,   0,   0,  32,   0, 
+      0,   0,  44,   0,   0,   0, 
+     96,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     16,  16,   0,   0,  32,   0, 
-      0,  96,   0,   0,   0,   0, 
+     22,   0,   0,   0,  25,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,  10,   0, 
-    204,   8,   0,   0,   0,   0, 
-      0,   0, 164,  14,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  84, 101, 
-    120, 116, 117, 114, 101,  80, 
-    105, 120, 101, 108,  83, 104, 
-     97, 100, 101, 114,   0, 110, 
-    111, 110, 101,   0,  45, 186, 
-     46, 241,   1,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,  16,  16, 
       0,   0,  32,   0,   0,  96, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      2,   0,   2,   0,   7,   0, 
-      0,   0,   0,   0,   1,   0, 
-    255, 255, 255, 255,   0,   0, 
+      2,   0,   9,   0, 204,   8, 
+      0,   0,   0,   0,   0,   0, 
+    164,  14,   0,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  84, 101, 120, 116, 
+    117, 114, 101,  80, 105, 120, 
+    101, 108,  83, 104,  97, 100, 
+    101, 114,   0, 110, 111, 110, 
+    101,   0,  45, 186,  46, 241, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,  16,  16,   0,   0, 
-      8,   2,   0,   0,   0,   0, 
+     32,   0,   0,  96,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   2,   0, 
+      2,   0,   7,   0,   0,   0, 
+      0,   0,   1,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+     16,  16,   0,   0,   8,   2, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
       0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   1,   0,   1,   0, 
+      1,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+     67,  58,  92,  85, 115, 101, 
+    114, 115,  92, 107, 111, 108, 
+    106,  97,  92,  68, 101, 115, 
+    107, 116, 111, 112,  92,  75, 
+    111, 108, 106,  97,  45,  83, 
+    116, 114, 111, 104, 109,  45, 
+     71,  97, 109, 101, 115,  92, 
+     65, 108, 108, 103, 101, 109, 
+    101, 105, 110,  92,  70, 114, 
+     97, 109, 101, 119, 111, 114, 
+    107,  92,  68,  88,  49,  49, 
+     80, 105, 120, 101, 108,  83, 
+    104,  97, 100, 101, 114,  46, 
+    104, 108, 115, 108,   0,   0, 
+    254, 239, 254, 239,   1,   0, 
       0,   0,   1,   0,   0,   0, 
-      0,   0,  67,  58,  92,  85, 
-    115, 101, 114, 115,  92, 107, 
-    111, 108, 106,  97,  92,  68, 
-    101, 115, 107, 116, 111, 112, 
-     92,  75, 111, 108, 106,  97, 
-     45,  83, 116, 114, 111, 104, 
-    109,  45,  71,  97, 109, 101, 
-    115,  92,  65, 108, 108, 103, 
-    101, 109, 101, 105, 110,  92, 
-     70, 114,  97, 109, 101, 119, 
-    111, 114, 107,  92,  68,  88, 
-     49,  49,  80, 105, 120, 101, 
-    108,  83, 104,  97, 100, 101, 
-    114,  46, 104, 108, 115, 108, 
-      0,   0, 254, 239, 254, 239, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   1,   0,   0, 
+      0,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255,  14,   0, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255,   0,   0,   0, 
+      0, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255, 255,  12, 
+      0, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255, 255,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5644,51 +5558,49 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 148,  46, 
-     49,   1,   6, 118,  88, 104, 
-      1,   0,   0,   0,  12, 187, 
-     61,  31, 237, 232,  43,  74, 
-    133, 102, 180, 150, 227, 104, 
-    208, 176, 155,   0,   0,   0, 
-     47,  76, 105, 110, 107,  73, 
-    110, 102, 111,   0,  47,  84, 
-     77,  67,  97,  99, 104, 101, 
-      0,  47, 110,  97, 109, 101, 
-    115,   0,  47, 115, 114,  99, 
-     47, 104, 101,  97, 100, 101, 
-    114,  98, 108, 111,  99, 107, 
-      0,  47, 115, 114,  99,  47, 
-    102, 105, 108, 101, 115,  47, 
-     99,  58,  92, 117, 115, 101, 
-    114, 115,  92, 107, 111, 108, 
-    106,  97,  92, 100, 101, 115, 
-    107, 116, 111, 112,  92, 107, 
-    111, 108, 106,  97,  45, 115, 
-    116, 114, 111, 104, 109,  45, 
-    103,  97, 109, 101, 115,  92, 
-     97, 108, 108, 103, 101, 109, 
-    101, 105, 110,  92, 102, 114, 
-     97, 109, 101, 119, 111, 114, 
-    107,  92, 100, 120,  49,  49, 
-    112, 105, 120, 101, 108, 115, 
-    104,  97, 100, 101, 114,  46, 
-    104, 108, 115, 108,   0,  47, 
-     85,  68,  84,  83,  82,  67, 
-     76,  73,  78,  69,  85,  78, 
-     68,  79,  78,  69,   0,   6, 
-      0,   0,   0,  10,   0,   0, 
-      0,   1,   0,   0,   0,  63, 
       0,   0,   0,   0,   0,   0, 
-      0, 137,   0,   0,   0,  12, 
-      0,   0,   0,  43,   0,   0, 
-      0,   9,   0,   0,   0,  26, 
-      0,   0,   0,   8,   0,   0, 
-      0,   0,   0,   0,   0,   5, 
-      0,   0,   0,  10,   0,   0, 
-      0,   6,   0,   0,   0,  19, 
-      0,   0,   0,   7,   0,   0, 
-      0,   0,   0,   0,   0, 220, 
-     81,  51,   1,   0,   0,   0, 
+      0,   0, 148,  46,  49,   1, 
+     77, 224, 173, 104,   1,   0, 
+      0,   0, 123, 114, 161,   2, 
+    247,  51,  29,  75, 162,  24, 
+     41, 116,  18, 220, 128,  57, 
+    128,   0,   0,   0,  47,  76, 
+    105, 110, 107,  73, 110, 102, 
+    111,   0,  47, 110,  97, 109, 
+    101, 115,   0,  47, 115, 114, 
+     99,  47, 104, 101,  97, 100, 
+    101, 114,  98, 108, 111,  99, 
+    107,   0,  47, 115, 114,  99, 
+     47, 102, 105, 108, 101, 115, 
+     47,  99,  58,  92, 117, 115, 
+    101, 114, 115,  92, 107, 111, 
+    108, 106,  97,  92, 100, 101, 
+    115, 107, 116, 111, 112,  92, 
+    107, 111, 108, 106,  97,  45, 
+    115, 116, 114, 111, 104, 109, 
+     45, 103,  97, 109, 101, 115, 
+     92,  97, 108, 108, 103, 101, 
+    109, 101, 105, 110,  92, 102, 
+    114,  97, 109, 101, 119, 111, 
+    114, 107,  92, 100, 120,  49, 
+     49, 112, 105, 120, 101, 108, 
+    115, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
+      4,   0,   0,   0,   6,   0, 
+      0,   0,   1,   0,   0,   0, 
+     58,   0,   0,   0,   0,   0, 
+      0,   0,  17,   0,   0,   0, 
+      7,   0,   0,   0,  10,   0, 
+      0,   0,   6,   0,   0,   0, 
+      0,   0,   0,   0,   5,   0, 
+      0,   0,  34,   0,   0,   0, 
+      8,   0,   0,   0,   0,   0, 
+      0,   0, 220,  81,  51,   1, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5730,37 +5642,39 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     18,   0,   0,   0,  40,   0, 
-      0,   0,   7,   1,   0,   0, 
-    206,   2,   0,   0, 117,   1, 
-      0,   0,  56,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  16,   0, 
+      0,   0,  32,   0,   0,   0, 
+    220,   0,   0,   0, 232,   2, 
+      0,   0, 115,   1,   0,   0, 
+     56,   0,   0,   0,   0,   0, 
       0,   0, 119,  19,   0,   0, 
     128,   0,   0,   0, 158,  18, 
       0,   0, 172,  23,   0,   0, 
     144,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-     40,   0,   0,   0, 188,   2, 
-      0,   0,  44,   0,   0,   0, 
-    248,   1,   0,   0,   7,   0, 
-      0,   0,  50,   0,   0,   0, 
-     34,   0,   0,   0,  33,   0, 
-      0,   0,  49,   0,   0,   0, 
-     35,   0,   0,   0,  19,   0, 
-      0,   0,   3,   0,   0,   0, 
+      0,   0,  40,   0,   0,   0, 
+    188,   2,   0,   0,  44,   0, 
+      0,   0, 248,   1,   0,   0, 
+      3,   0,   0,   0,  49,   0, 
+      0,   0,  33,   0,   0,   0, 
+     32,   0,   0,   0,  48,   0, 
+      0,   0,  34,   0,   0,   0, 
+     18,   0,   0,   0,   6,   0, 
+      0,   0,  35,   0,   0,   0, 
      36,   0,   0,   0,  37,   0, 
       0,   0,  38,   0,   0,   0, 
      39,   0,   0,   0,  40,   0, 
       0,   0,  41,   0,   0,   0, 
-     42,   0,   0,   0,  43,   0, 
-      0,   0,  20,   0,   0,   0, 
+     42,   0,   0,   0,  19,   0, 
+      0,   0,   8,   0,   0,   0, 
       9,   0,   0,   0,  10,   0, 
       0,   0,  11,   0,   0,   0, 
      12,   0,   0,   0,  13,   0, 
       0,   0,  14,   0,   0,   0, 
      15,   0,   0,   0,  16,   0, 
       0,   0,  17,   0,   0,   0, 
-     18,   0,   0,   0,  21,   0, 
+     20,   0,   0,   0,  21,   0, 
       0,   0,  22,   0,   0,   0, 
      23,   0,   0,   0,  24,   0, 
       0,   0,  25,   0,   0,   0, 
@@ -5768,11 +5682,98 @@ const BYTE UIPixelShader[] =
       0,   0,  28,   0,   0,   0, 
      29,   0,   0,   0,  30,   0, 
       0,   0,  31,   0,   0,   0, 
-     32,   0,   0,   0,   4,   0, 
+      7,   0,   0,   0,  43,   0, 
       0,   0,  44,   0,   0,   0, 
-     45,   0,   0,   0,  46,   0, 
-      0,   0,  48,   0,   0,   0, 
-     47,   0,   0,   0,   0,   0, 
+     45,   0,   0,   0,  47,   0, 
+      0,   0,  46,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     50,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -5815,7 +5816,6 @@ const BYTE UIPixelShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  51,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 

UIVertexShader.h

@@ -121,10 +121,10 @@ ret
 
 const BYTE UIVertexShader[] =
 {
-     68,  88,  66,  67,  33, 214, 
-    237, 128, 247, 136, 239, 191, 
-      4,  83,  70,  79,  81, 112, 
-     91,  29,   1,   0,   0,   0, 
+     68,  88,  66,  67,  48, 182, 
+     67,  81, 100, 119,  46, 199, 
+     51, 213, 186,  99, 229, 142, 
+    111, 238,   1,   0,   0,   0, 
     204,  77,   0,   0,   6,   0, 
       0,   0,  56,   0,   0,   0, 
      20,   2,   0,   0, 204,   2, 
@@ -459,10 +459,10 @@ const BYTE UIVertexShader[] =
      43,  32,  77,  83,  70,  32, 
      55,  46,  48,  48,  13,  10, 
      26,  68,  83,   0,   0,   0, 
-      0,   2,   0,   0,   1,   0, 
+      0,   2,   0,   0,   2,   0, 
       0,   0,  35,   0,   0,   0, 
-    180,   0,   0,   0,   0,   0, 
-      0,   0,  33,   0,   0,   0, 
+    172,   0,   0,   0,   0,   0, 
+      0,   0,  32,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -539,8 +539,7 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    224,   1,   0,   0, 252, 255, 
-    255, 255, 255, 255, 255, 255, 
+    192, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -624,8 +623,9 @@ const BYTE UIVertexShader[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    255, 255,  24, 254, 255, 255, 
     255, 255, 255, 255, 255, 255, 
+    255, 255,  56,   0,   0,   0, 
+    254, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
@@ -709,149 +709,12 @@ const BYTE UIVertexShader[] =
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
     255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255,  83,  32, 
-     47,  47,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  86, 101, 114, 116, 101, 
-    120,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  13,  10, 
-    123,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  58,  32,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
-     59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  50,  32, 116, 
-    101, 120,  32,  58,  32,  84, 
-     69,  88,  67,  79,  79,  82, 
-     68,  48,  59,  13,  10,   9, 
-    102, 108, 111,  97, 116,  51, 
-     32, 110, 111, 114, 109,  97, 
-    108,  32,  58,  32,  78,  79, 
-     82,  77,  65,  76,  59,  13, 
-     10,   9, 117, 105, 110, 116, 
-     32, 107, 110, 111,  99, 104, 
-    101, 110,  32,  58,  32,  75, 
-     78,  79,  67,  72,  69,  78, 
-     95,  73,  68,  48,  59,  13, 
-     10,   9, 117, 105, 110, 116, 
-     32, 105, 100,  32,  58,  32, 
-     86,  69,  82,  84,  69,  88, 
-     95,  73,  68,  48,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  80, 105, 120, 101, 
-    108,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  13,  10, 
-    123,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,  32,  58,  32,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
-     59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  58,  32,  83,  86, 
-     95,  80,  79,  83,  73,  84, 
-     73,  79,  78,  59,  13,  10, 
-      9, 102, 108, 111,  97, 116, 
-     50,  32, 116, 101, 120,  32, 
-     58,  32,  84,  69,  88,  67, 
-     79,  79,  82,  68,  48,  59, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  51,  32, 110, 111, 
-    114, 109,  97, 108,  32,  58, 
-     32,  84,  69,  88,  67,  79, 
-     79,  82,  68,  49,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
-     14, 219,   3,   0, 197,  74, 
-      0,   0, 165, 207,   1,   0, 
-     81, 207,   1,   0, 146, 183, 
-      2,   0,  28,  19,   2,   0, 
-    242,  56,   1,   0,  43, 236, 
-      3,   0, 217,  42,   2,   0, 
-     38, 107,   0,   0, 103, 159, 
-      1,   0,  73,  20,   1,   0, 
-    208, 163,   2,   0,  65, 185, 
-      2,   0, 153, 189,   3,   0, 
-      0,  16,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   5,   0, 
+      0,   0,  32,   0,   0,   0, 
+     60,   0,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0,   6,   0, 
+      0,   0,   5,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -880,17 +743,8 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 148,  46,  49,   1, 
-      7, 118,  88, 104,   1,   0, 
-      0,   0,  44, 121, 113, 213, 
-     73,   7,  91,  71, 128,  68, 
-    217, 177, 225, 239,  72, 143, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 220,  81, 
-     51,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -941,6 +795,7 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -965,11 +820,6 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255, 119,   9,  49,   1, 
-      0,   0,   0,   0, 255, 255, 
-      0,   0, 255, 255,   0,   0, 
-    255, 255,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1030,8 +880,17 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0, 148,  46,  49,   1, 
+     77, 224, 173, 104,   1,   0, 
+      0,   0, 175, 104, 189,  60, 
+     55, 199,  66,  76, 173,  77, 
+     99, 193,  35,  69,  23, 180, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 220,  81, 
+     51,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1051,13 +910,7 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      6,   0,   0,   0,  32,   0, 
-      0,   0,  60,   0,   0,   0, 
-      0,   0,   0,   0,  64,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   3,   0, 
-      0,   0,   5,   0,   0,   0, 
-      6,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1112,6 +965,103 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  83,  32, 
+     47,  47,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  13,  10, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  13,  10, 
+    115, 116, 114, 117,  99, 116, 
+     32,  86, 101, 114, 116, 101, 
+    120,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,  13,  10, 
+    123,  13,  10,   9, 102, 108, 
+    111,  97, 116,  52,  32, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  58,  32,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,   9, 102, 108, 
+    111,  97, 116,  50,  32, 116, 
+    101, 120,  32,  58,  32,  84, 
+     69,  88,  67,  79,  79,  82, 
+     68,  48,  59,  13,  10,   9, 
+    102, 108, 111,  97, 116,  51, 
+     32, 110, 111, 114, 109,  97, 
+    108,  32,  58,  32,  78,  79, 
+     82,  77,  65,  76,  59,  13, 
+     10,   9, 117, 105, 110, 116, 
+     32, 107, 110, 111,  99, 104, 
+    101, 110,  32,  58,  32,  75, 
+     78,  79,  67,  72,  69,  78, 
+     95,  73,  68,  48,  59,  13, 
+     10,   9, 117, 105, 110, 116, 
+     32, 105, 100,  32,  58,  32, 
+     86,  69,  82,  84,  69,  88, 
+     95,  73,  68,  48,  59,  13, 
+     10, 125,  59,  13,  10,  13, 
+     10, 115, 116, 114, 117,  99, 
+    116,  32,  80, 105, 120, 101, 
+    108,  73, 110, 112, 117, 116, 
+     84, 121, 112, 101,  13,  10, 
+    123,  13,  10,   9, 102, 108, 
+    111,  97, 116,  52,  32, 119, 
+    111, 114, 108, 100,  80, 111, 
+    115,  32,  58,  32,  80,  79, 
+     83,  73,  84,  73,  79,  78, 
+     59,  13,  10,   9, 102, 108, 
+    111,  97, 116,  52,  32, 112, 
+    111, 115, 105, 116, 105, 111, 
+    110,  32,  58,  32,  83,  86, 
+     95,  80,  79,  83,  73,  84, 
+     73,  79,  78,  59,  13,  10, 
+      9, 102, 108, 111,  97, 116, 
+     50,  32, 116, 101, 120,  32, 
+     58,  32,  84,  69,  88,  67, 
+     79,  79,  82,  68,  48,  59, 
+     13,  10,   9, 102, 108, 111, 
+     97, 116,  51,  32, 110, 111, 
+    114, 109,  97, 108,  32,  58, 
+     32,  84,  69,  88,  67,  79, 
+     79,  82,  68,  49,  59,  13, 
+     10, 125,  59,  13,  10,  13, 
+     10,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+    198,  90,   0,   0, 117, 131, 
+      1,   0,  76, 232,   3,   0, 
+     81, 207,   1,   0, 146, 183, 
+      2,   0,  28,  19,   2,   0, 
+    242,  56,   1,   0,  43, 236, 
+      3,   0, 217,  42,   2,   0, 
+     38, 107,   0,   0, 103, 159, 
+      1,   0,  73,  20,   1,   0, 
+     19,  54,   2,   0,  65, 185, 
+      2,   0, 153, 189,   3,   0, 
+      0,  16,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1136,7 +1086,6 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   7,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1187,82 +1136,47 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  47,  47, 
+      0,   0,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  13, 
-     10,  47,  47,  32,  71,  76, 
-     79,  66,  65,  76,  83,  32, 
-     47,  47,  13,  10,  47,  47, 
+     47,  47,  47,  13,  10,  47, 
+     47,  32,  71,  76,  79,  66, 
+     65,  76,  83,  32,  47,  47, 
+     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  13, 
+     47,  47,  47,  13,  10,  99, 
+     98, 117, 102, 102, 101, 114, 
+     32,  77,  97, 116, 114, 105, 
+    120,  66, 117, 102, 102, 101, 
+    114,  32,  58,  32, 114, 101, 
+    103, 105, 115, 116, 101, 114, 
+     40,  98,  48,  41,  13,  10, 
+    123,  13,  10,   9, 109,  97, 
+    116, 114, 105, 120,  32, 107, 
+    110, 111,  99, 104, 101, 110, 
+     77,  97, 116, 114, 105, 120, 
+     91,  49,  50,  56,  93,  59, 
+     13,  10, 125,  59,  13,  10, 
+     13,  10,  47,  47,  32,  84, 
+    104, 101,  32, 112, 114, 111, 
+    106, 101,  99, 116, 105, 111, 
+    110,  32,  97, 110, 100,  32, 
+    118, 105, 101, 119,  32, 109, 
+     97, 116, 114, 105, 120,  13, 
      10,  99,  98, 117, 102, 102, 
-    101, 114,  32,  77,  97, 116, 
-    114, 105, 120,  66, 117, 102, 
-    102, 101, 114,  32,  58,  32, 
+    101, 114,  32,  75,  97, 109, 
+    101, 114,  97,  32,  58,  32, 
     114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  98,  48,  41, 
+    101, 114,  40,  98,  49,  41, 
      13,  10, 123,  13,  10,   9, 
     109,  97, 116, 114, 105, 120, 
-     32, 107, 110, 111,  99, 104, 
-    101, 110,  77,  97, 116, 114, 
-    105, 120,  91,  49,  50,  56, 
-     93,  59,  13,  10, 125,  59, 
+     32, 118, 105, 101, 119,  59, 
+     13,  10,   9, 109,  97, 116, 
+    114, 105, 120,  32, 112, 114, 
+    111, 106, 101,  99, 116, 105, 
+    111, 110,  59,  13,  10, 125, 
      13,  10,  13,  10,  47,  47, 
-     32,  84, 104, 101,  32, 112, 
-    114, 111, 106, 101,  99, 116, 
-    105, 111, 110,  32,  97, 110, 
-    100,  32, 118, 105, 101, 119, 
-     32, 109,  97, 116, 114, 105, 
-    120,  13,  10,  99,  98, 117, 
-    102, 102, 101, 114,  32,  75, 
-     97, 109, 101, 114,  97,  32, 
-     58,  32, 114, 101, 103, 105, 
-    115, 116, 101, 114,  40,  98, 
-     49,  41,  13,  10, 123,  13, 
-     10,   9, 109,  97, 116, 114, 
-    105, 120,  32, 118, 105, 101, 
-    119,  59,  13,  10,   9, 109, 
-     97, 116, 114, 105, 120,  32, 
-    112, 114, 111, 106, 101,  99, 
-    116, 105, 111, 110,  59,  13, 
-     10, 125,  13,  10,  13,  10, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1274,11 +1188,10 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-     47,  47,  32,  84,  89,  80, 
-     69,  68,  69,  70,  83,  32, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,  47,  47, 
+     32,  84,  89,  80,  69,  68, 
+     69,  70,  83,  32,  47,  47, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1289,10 +1202,11 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1304,61 +1218,61 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-    115, 116, 114, 117,  99, 116, 
-     32,  86, 101, 114, 116, 101, 
-    120,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  13,  10, 
-    123,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  58,  32,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10, 115, 116, 
+    114, 117,  99, 116,  32,  86, 
+    101, 114, 116, 101, 120,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,  13,  10, 123,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  52,  32, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+     58,  32,  80,  79,  83,  73, 
+     84,  73,  79,  78,  59,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  50,  32, 116, 101, 120, 
+     32,  58,  32,  84,  69,  88, 
+     67,  79,  79,  82,  68,  48, 
      59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  50,  32, 116, 
-    101, 120,  32,  58,  32,  84, 
-     69,  88,  67,  79,  79,  82, 
+    111,  97, 116,  51,  32, 110, 
+    111, 114, 109,  97, 108,  32, 
+     58,  32,  78,  79,  82,  77, 
+     65,  76,  59,  13,  10,   9, 
+    117, 105, 110, 116,  32, 107, 
+    110, 111,  99, 104, 101, 110, 
+     32,  58,  32,  75,  78,  79, 
+     67,  72,  69,  78,  95,  73, 
      68,  48,  59,  13,  10,   9, 
-    102, 108, 111,  97, 116,  51, 
-     32, 110, 111, 114, 109,  97, 
-    108,  32,  58,  32,  78,  79, 
-     82,  77,  65,  76,  59,  13, 
-     10,   9, 117, 105, 110, 116, 
-     32, 107, 110, 111,  99, 104, 
-    101, 110,  32,  58,  32,  75, 
-     78,  79,  67,  72,  69,  78, 
-     95,  73,  68,  48,  59,  13, 
-     10,   9, 117, 105, 110, 116, 
-     32, 105, 100,  32,  58,  32, 
-     86,  69,  82,  84,  69,  88, 
-     95,  73,  68,  48,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10, 115, 116, 114, 117,  99, 
-    116,  32,  80, 105, 120, 101, 
-    108,  73, 110, 112, 117, 116, 
-     84, 121, 112, 101,  13,  10, 
-    123,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,  32,  58,  32,  80,  79, 
-     83,  73,  84,  73,  79,  78, 
-     59,  13,  10,   9, 102, 108, 
-    111,  97, 116,  52,  32, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  32,  58,  32,  83,  86, 
-     95,  80,  79,  83,  73,  84, 
-     73,  79,  78,  59,  13,  10, 
+    117, 105, 110, 116,  32, 105, 
+    100,  32,  58,  32,  86,  69, 
+     82,  84,  69,  88,  95,  73, 
+     68,  48,  59,  13,  10, 125, 
+     59,  13,  10,  13,  10, 115, 
+    116, 114, 117,  99, 116,  32, 
+     80, 105, 120, 101, 108,  73, 
+    110, 112, 117, 116,  84, 121, 
+    112, 101,  13,  10, 123,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  52,  32, 119, 111, 114, 
+    108, 100,  80, 111, 115,  32, 
+     58,  32,  80,  79,  83,  73, 
+     84,  73,  79,  78,  59,  13, 
+     10,   9, 102, 108, 111,  97, 
+    116,  52,  32, 112, 111, 115, 
+    105, 116, 105, 111, 110,  32, 
+     58,  32,  83,  86,  95,  80, 
+     79,  83,  73,  84,  73,  79, 
+     78,  59,  13,  10,   9, 102, 
+    108, 111,  97, 116,  50,  32, 
+    116, 101, 120,  32,  58,  32, 
+     84,  69,  88,  67,  79,  79, 
+     82,  68,  48,  59,  13,  10, 
       9, 102, 108, 111,  97, 116, 
-     50,  32, 116, 101, 120,  32, 
-     58,  32,  84,  69,  88,  67, 
-     79,  79,  82,  68,  48,  59, 
-     13,  10,   9, 102, 108, 111, 
-     97, 116,  51,  32, 110, 111, 
-    114, 109,  97, 108,  32,  58, 
-     32,  84,  69,  88,  67,  79, 
-     79,  82,  68,  49,  59,  13, 
-     10, 125,  59,  13,  10,  13, 
-     10,  47,  47,  47,  47,  47, 
+     51,  32, 110, 111, 114, 109, 
+     97, 108,  32,  58,  32,  84, 
+     69,  88,  67,  79,  79,  82, 
+     68,  49,  59,  13,  10, 125, 
+     59,  13,  10,  13,  10,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -1371,11 +1285,11 @@ const BYTE UIVertexShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  13,  10,  47, 
-     47,  32,  86, 101, 114, 116, 
-    101, 120,  32,  83, 104,  97, 
-    100, 101, 114,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
+     47,  47,  47,  47,  47,  47, 
+     47,  13,  10,  47,  47,  32, 
+     86, 101, 114, 116, 101, 120, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1385,7 +1299,8 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  13,  10,  47,  47,  47, 
+     32,  32,  32,  32,  32,  13, 
+     10,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -1398,21 +1313,20 @@ const BYTE UIVertexShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  13, 
-     10,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32,  84, 101, 
-    120, 116, 117, 114, 101,  86, 
-    101, 114, 116, 101, 120,  83, 
-    104,  97, 100, 101, 114,  40, 
-     86, 101, 114, 116, 101, 120, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 105, 110, 
-    112, 117, 116,  41,  13,  10, 
-    123,  13,  10,   9,  47,  47, 
-    114, 101, 116, 117, 114, 110, 
-     32, 105, 110, 112, 117, 116, 
-     59,  32,  32,  32,  32,  32, 
+     47,  47,  47,  13,  10,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32,  84, 101, 120, 116, 
+    117, 114, 101,  86, 101, 114, 
+    116, 101, 120,  83, 104,  97, 
+    100, 101, 114,  40,  86, 101, 
+    114, 116, 101, 120,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 105, 110, 112, 117, 
+    116,  41,  13,  10, 123,  13, 
+     10,   9,  47,  47, 114, 101, 
+    116, 117, 114, 110,  32, 105, 
+    110, 112, 117, 116,  59,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1423,113 +1337,113 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-      9,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 111, 117, 
-    116, 112, 117, 116,  59,  13, 
-     10,   9, 111, 117, 116, 112, 
-    117, 116,  46, 110, 111, 114, 
-    109,  97, 108,  32,  61,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,   9,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 111, 117, 116, 112, 
+    117, 116,  59,  13,  10,   9, 
+    111, 117, 116, 112, 117, 116, 
+     46, 110, 111, 114, 109,  97, 
+    108,  32,  61,  32, 110, 111, 
+    114, 109,  97, 108, 105, 122, 
+    101,  40, 109, 117, 108,  40, 
+    105, 110, 112, 117, 116,  46, 
     110, 111, 114, 109,  97, 108, 
-    105, 122, 101,  40, 109, 117, 
-    108,  40, 105, 110, 112, 117, 
-    116,  46, 110, 111, 114, 109, 
-     97, 108,  44,  32,  40, 102, 
-    108, 111,  97, 116,  51, 120, 
-     51,  41, 107, 110, 111,  99, 
+     44,  32,  40, 102, 108, 111, 
+     97, 116,  51, 120,  51,  41, 
+    107, 110, 111,  99, 104, 101, 
+    110,  77,  97, 116, 114, 105, 
+    120,  91, 105, 110, 112, 117, 
+    116,  46, 107, 110, 111,  99, 
+    104, 101, 110,  93,  41,  41, 
+     59,  13,  10,  13,  10,   9, 
+     47,  47,  32,  67, 104,  97, 
+    110, 103, 101,  32, 116, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 118, 
+    101,  99, 116, 111, 114,  32, 
+    116, 111,  32,  98, 101,  32, 
+     52,  32, 117, 110, 105, 116, 
+    115,  32, 102, 111, 114,  32, 
+    112, 114, 111, 112, 101, 114, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32,  99,  97, 108,  99, 
+    117, 108,  97, 116, 105, 111, 
+    110, 115,  46,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     13,  10,   9, 105, 110, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    119,  32,  61,  32,  49,  46, 
+     48, 102,  59,  13,  10,  13, 
+     10,   9,  47,  47,  32,  83, 
+    116, 111, 114, 101,  32, 116, 
+    104, 101,  32, 116, 101, 120, 
+    116, 117, 114, 101,  32,  99, 
+    111, 111, 114, 100, 105, 110, 
+     97, 116, 101, 115,  32, 102, 
+    111, 114,  32, 116, 104, 101, 
+     32, 112, 105, 120, 101, 108, 
+     32, 115, 104,  97, 100, 101, 
+    114,  46,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,   9, 111, 
+    117, 116, 112, 117, 116,  46, 
+    116, 101, 120,  32,  61,  32, 
+    105, 110, 112, 117, 116,  46, 
+    116, 101, 120,  59,  13,  10, 
+     13,  10,   9,  47,  47,  32, 
+     67,  97, 108,  99, 117, 108, 
+     97, 116, 101,  32, 116, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 111, 
+    102,  32, 116, 104, 101,  32, 
+    118, 101, 114, 116, 101, 120, 
+     32,  97, 103,  97, 105, 110, 
+    115, 116,  32, 116, 104, 101, 
+     32, 119, 111, 114, 108, 100, 
+     44,  32, 118, 105, 101, 119, 
+     44,  32,  97, 110, 100,  32, 
+    112, 114, 111, 106, 101,  99, 
+    116, 105, 111, 110,  32, 109, 
+     97, 116, 114, 105,  99, 101, 
+    115,  46,  32,  13,  10,   9, 
+    111, 117, 116, 112, 117, 116, 
+     46, 119, 111, 114, 108, 100, 
+     80, 111, 115,  32,  61,  32, 
+    109, 117, 108,  40, 105, 110, 
+    112, 117, 116,  46, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     44,  32, 107, 110, 111,  99, 
     104, 101, 110,  77,  97, 116, 
     114, 105, 120,  91, 105, 110, 
     112, 117, 116,  46, 107, 110, 
     111,  99, 104, 101, 110,  93, 
-     41,  41,  59,  13,  10,  13, 
-     10,   9,  47,  47,  32,  67, 
-    104,  97, 110, 103, 101,  32, 
-    116, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 118, 101,  99, 116, 111, 
-    114,  32, 116, 111,  32,  98, 
-    101,  32,  52,  32, 117, 110, 
-    105, 116, 115,  32, 102, 111, 
-    114,  32, 112, 114, 111, 112, 
-    101, 114,  32, 109,  97, 116, 
-    114, 105, 120,  32,  99,  97, 
-    108,  99, 117, 108,  97, 116, 
-    105, 111, 110, 115,  46,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,   9, 105, 
-    110, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 119,  32,  61,  32, 
-     49,  46,  48, 102,  59,  13, 
-     10,  13,  10,   9,  47,  47, 
-     32,  83, 116, 111, 114, 101, 
-     32, 116, 104, 101,  32, 116, 
-    101, 120, 116, 117, 114, 101, 
-     32,  99, 111, 111, 114, 100, 
-    105, 110,  97, 116, 101, 115, 
-     32, 102, 111, 114,  32, 116, 
-    104, 101,  32, 112, 105, 120, 
-    101, 108,  32, 115, 104,  97, 
-    100, 101, 114,  46,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 116, 101, 120,  32, 
-     61,  32, 105, 110, 112, 117, 
-    116,  46, 116, 101, 120,  59, 
-     13,  10,  13,  10,   9,  47, 
-     47,  32,  67,  97, 108,  99, 
-    117, 108,  97, 116, 101,  32, 
-    116, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 111, 102,  32, 116, 104, 
-    101,  32, 118, 101, 114, 116, 
-    101, 120,  32,  97, 103,  97, 
-    105, 110, 115, 116,  32, 116, 
-    104, 101,  32, 119, 111, 114, 
-    108, 100,  44,  32, 118, 105, 
-    101, 119,  44,  32,  97, 110, 
-    100,  32, 112, 114, 111, 106, 
-    101,  99, 116, 105, 111, 110, 
-     32, 109,  97, 116, 114, 105, 
-     99, 101, 115,  46,  32,  13, 
-     10,   9, 111, 117, 116, 112, 
-    117, 116,  46, 119, 111, 114, 
-    108, 100,  80, 111, 115,  32, 
-     61,  32, 109, 117, 108,  40, 
-    105, 110, 112, 117, 116,  46, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  44,  32, 107, 110, 
-    111,  99, 104, 101, 110,  77, 
-     97, 116, 114, 105, 120,  91, 
-    105, 110, 112, 117, 116,  46, 
-    107, 110, 111,  99, 104, 101, 
-    110,  93,  41,  59,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  61, 
-     32, 109, 117, 108,  40, 111, 
+     41,  59,  13,  10,   9, 111, 
     117, 116, 112, 117, 116,  46, 
-    119, 111, 114, 108, 100,  80, 
-    111, 115,  44,  32, 118, 105, 
-    101, 119,  41,  59,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  61, 
-     32, 109, 117, 108,  40, 111, 
+    112, 111, 115, 105, 116, 105, 
+    111, 110,  32,  61,  32, 109, 
+    117, 108,  40, 111, 117, 116, 
+    112, 117, 116,  46, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+     44,  32, 118, 105, 101, 119, 
+     41,  59,  13,  10,   9, 111, 
     117, 116, 112, 117, 116,  46, 
     112, 111, 115, 105, 116, 105, 
-    111, 110,  44,  32, 112, 114, 
-    111, 106, 101,  99, 116, 105, 
-    111, 110,  41,  59,  13,  10, 
-     13,  10,   9, 114, 101, 116, 
-    117, 114, 110,  32, 111, 117, 
-    116, 112, 117, 116,  59,  13, 
-     10, 125,   0,   0,   0,   0, 
+    111, 110,  32,  61,  32, 109, 
+    117, 108,  40, 111, 117, 116, 
+    112, 117, 116,  46, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     44,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
+     41,  59,  13,  10,  13,  10, 
+      9, 114, 101, 116, 117, 114, 
+    110,  32, 111, 117, 116, 112, 
+    117, 116,  59,  13,  10, 125, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1563,77 +1477,78 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    254, 239, 254, 239,   1,   0, 
-      0,   0, 225,   7,   0,   0, 
-      0,  67,  58,  92,  85, 115, 
-    101, 114, 115,  92, 107, 111, 
-    108, 106,  97,  92,  68, 101, 
-    115, 107, 116, 111, 112,  92, 
-     75, 111, 108, 106,  97,  45, 
-     83, 116, 114, 111, 104, 109, 
-     45,  71,  97, 109, 101, 115, 
-     92,  65, 108, 108, 103, 101, 
-    109, 101, 105, 110,  92,  70, 
-    114,  97, 109, 101, 119, 111, 
-    114, 107,  92,  68,  88,  49, 
-     49,  86, 101, 114, 116, 101, 
-    120,  83, 104,  97, 100, 101, 
-    114,  46, 104, 108, 115, 108, 
-      0,   0,  99,  58,  92, 117, 
-    115, 101, 114, 115,  92, 107, 
-    111, 108, 106,  97,  92, 100, 
-    101, 115, 107, 116, 111, 112, 
-     92, 107, 111, 108, 106,  97, 
-     45, 115, 116, 114, 111, 104, 
-    109,  45, 103,  97, 109, 101, 
-    115,  92,  97, 108, 108, 103, 
-    101, 109, 101, 105, 110,  92, 
-    102, 114,  97, 109, 101, 119, 
-    111, 114, 107,  92, 100, 120, 
-     49,  49, 118, 101, 114, 116, 
-    101, 120, 115, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0,  47,  47,  47,  47, 
+      0,   0,   0,   0, 254, 239, 
+    254, 239,   1,   0,   0,   0, 
+    225,   7,   0,   0,   0,  67, 
+     58,  92,  85, 115, 101, 114, 
+    115,  92, 107, 111, 108, 106, 
+     97,  92,  68, 101, 115, 107, 
+    116, 111, 112,  92,  75, 111, 
+    108, 106,  97,  45,  83, 116, 
+    114, 111, 104, 109,  45,  71, 
+     97, 109, 101, 115,  92,  65, 
+    108, 108, 103, 101, 109, 101, 
+    105, 110,  92,  70, 114,  97, 
+    109, 101, 119, 111, 114, 107, 
+     92,  68,  88,  49,  49,  86, 
+    101, 114, 116, 101, 120,  83, 
+    104,  97, 100, 101, 114,  46, 
+    104, 108, 115, 108,   0,   0, 
+     99,  58,  92, 117, 115, 101, 
+    114, 115,  92, 107, 111, 108, 
+    106,  97,  92, 100, 101, 115, 
+    107, 116, 111, 112,  92, 107, 
+    111, 108, 106,  97,  45, 115, 
+    116, 114, 111, 104, 109,  45, 
+    103,  97, 109, 101, 115,  92, 
+     97, 108, 108, 103, 101, 109, 
+    101, 105, 110,  92, 102, 114, 
+     97, 109, 101, 119, 111, 114, 
+    107,  92, 100, 120,  49,  49, 
+    118, 101, 114, 116, 101, 120, 
+    115, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  13,  10,  47, 
-     47,  32,  71,  76,  79,  66, 
-     65,  76,  83,  32,  47,  47, 
-     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  13,  10,  99, 
+     47,  13,  10,  47,  47,  32, 
+     71,  76,  79,  66,  65,  76, 
+     83,  32,  47,  47,  13,  10, 
+     47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  47,  47, 
+     47,  13,  10,  99,  98, 117, 
+    102, 102, 101, 114,  32,  77, 
+     97, 116, 114, 105, 120,  66, 
+    117, 102, 102, 101, 114,  32, 
+     58,  32, 114, 101, 103, 105, 
+    115, 116, 101, 114,  40,  98, 
+     48,  41,  13,  10, 123,  13, 
+     10,   9, 109,  97, 116, 114, 
+    105, 120,  32, 107, 110, 111, 
+     99, 104, 101, 110,  77,  97, 
+    116, 114, 105, 120,  91,  49, 
+     50,  56,  93,  59,  13,  10, 
+    125,  59,  13,  10,  13,  10, 
+     47,  47,  32,  84, 104, 101, 
+     32, 112, 114, 111, 106, 101, 
+     99, 116, 105, 111, 110,  32, 
+     97, 110, 100,  32, 118, 105, 
+    101, 119,  32, 109,  97, 116, 
+    114, 105, 120,  13,  10,  99, 
      98, 117, 102, 102, 101, 114, 
-     32,  77,  97, 116, 114, 105, 
-    120,  66, 117, 102, 102, 101, 
-    114,  32,  58,  32, 114, 101, 
+     32,  75,  97, 109, 101, 114, 
+     97,  32,  58,  32, 114, 101, 
     103, 105, 115, 116, 101, 114, 
-     40,  98,  48,  41,  13,  10, 
+     40,  98,  49,  41,  13,  10, 
     123,  13,  10,   9, 109,  97, 
-    116, 114, 105, 120,  32, 107, 
-    110, 111,  99, 104, 101, 110, 
-     77,  97, 116, 114, 105, 120, 
-     91,  49,  50,  56,  93,  59, 
-     13,  10, 125,  59,  13,  10, 
-     13,  10,  47,  47,  32,  84, 
-    104, 101,  32, 112, 114, 111, 
-    106, 101,  99, 116, 105, 111, 
-    110,  32,  97, 110, 100,  32, 
-    118, 105, 101, 119,  32, 109, 
-     97, 116, 114, 105, 120,  13, 
-     10,  99,  98, 117, 102, 102, 
-    101, 114,  32,  75,  97, 109, 
-    101, 114,  97,  32,  58,  32, 
-    114, 101, 103, 105, 115, 116, 
-    101, 114,  40,  98,  49,  41, 
-     13,  10, 123,  13,  10,   9, 
-    109,  97, 116, 114, 105, 120, 
-     32, 118, 105, 101, 119,  59, 
-     13,  10,   9, 109,  97, 116, 
-    114, 105, 120,  32, 112, 114, 
-    111, 106, 101,  99, 116, 105, 
-    111, 110,  59,  13,  10, 125, 
-     13,  10,  13,  10,  47,  47, 
-     47,  47,  47,  47,  47,  47, 
+    116, 114, 105, 120,  32, 118, 
+    105, 101, 119,  59,  13,  10, 
+      9, 109,  97, 116, 114, 105, 
+    120,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
+     59,  13,  10, 125,  13,  10, 
+     13,  10,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
+     47,  47,  47,  47,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -1646,33 +1561,27 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,  47,  47, 
-     32,  84,  89,  80,  69,  68, 
-     69,  70,  27, 226,  48,   1, 
-    128,   0,   0,   0, 129,  10, 
-    209, 234, 188, 227, 219,   1, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+     13,  10,  47,  47,  32,  84, 
+     89,  80,  69,  68,  69,  70, 
+     27, 226,  48,   1, 128,   0, 
+      0,   0, 182,  62, 150,  59, 
+    166,  22, 220,   1,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      1,   0,   0,   0,   2,   0, 
-      0,   0,   1,   0,   0,   0, 
-      1,   0,   0,   0,   0,   0, 
-      0,   0,  86,   0,   0,   0, 
-     40,   0,   0,   0,  27, 226, 
-     48,   1, 230, 118, 208, 224, 
-     54,   7,   0,   0,   1,   0, 
-      0,   0,  85,   0,   0,   0, 
-     86,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   2,   0,   0,   0, 
+      1,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
+     86,   0,   0,   0,  40,   0, 
+      0,   0,  27, 226,  48,   1, 
+    230, 118, 208, 224,  54,   7, 
+      0,   0,   1,   0,   0,   0, 
+     85,   0,   0,   0,  86,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -1733,365 +1642,371 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   4,   0, 
-      0,   0,  66,   0,  60,  17, 
-     16,   1,   0,   0,   0,   1, 
-     10,   0,   1,   0,  76,  15, 
-    244, 101,  10,   0,   1,   0, 
-     76,  15, 244, 101,  77, 105, 
-     99, 114, 111, 115, 111, 102, 
-    116,  32,  40,  82,  41,  32, 
-     72,  76,  83,  76,  32,  83, 
-    104,  97, 100, 101, 114,  32, 
-     67, 111, 109, 112, 105, 108, 
-    101, 114,  32,  49,  48,  46, 
-     49,   0,   0,   0,  66,   0, 
-     61,  17,   1, 104, 108, 115, 
-    108,  70, 108,  97, 103, 115, 
-      0,  48, 120,  53,   0, 104, 
-    108, 115, 108,  84,  97, 114, 
-    103, 101, 116,   0, 118, 115, 
-     95,  53,  95,  48,   0, 104, 
-    108, 115, 108,  69, 110, 116, 
-    114, 121,   0,  84, 101, 120, 
-    116, 117, 114, 101,  86, 101, 
-    114, 116, 101, 120,  83, 104, 
-     97, 100, 101, 114,   0,   0, 
-     58,   0,  16,  17,   0,   0, 
-      0,   0, 100,   5,   0,   0, 
-      0,   0,   0,   0,  44,   3, 
       0,   0,   0,   0,   0,   0, 
-     44,   3,   0,   0,   9,  16, 
-      0,   0, 152,   0,   0,   0, 
-      1,   0, 160,  84, 101, 120, 
-    116, 117, 114, 101,  86, 101, 
-    114, 116, 101, 120,  83, 104, 
-     97, 100, 101, 114,   0,   0, 
-     46,   0,  62,  17,   4,  16, 
-      0,   0,   9,   0, 105, 110, 
-    112, 117, 116,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   0,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,   0,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   4,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,   4,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,   8,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,   8,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  12,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  12,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  16,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  16,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  20,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  20,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  24,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  32,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  28,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  36,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  32,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  40,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  36,   0,   4,   0, 
-    152,   0,   0,   0,   1,   0, 
-     44,   3,  48,   0,   0,   0, 
-     22,   0,  80,  17,   1,   0, 
-      5,   0,  40,   0,   4,   0, 
+      0,   0,   4,   0,   0,   0, 
+     66,   0,  60,  17,  16,   1, 
+      0,   0,   0,   1,  10,   0, 
+      1,   0,  46,  18, 244, 101, 
+     10,   0,   1,   0,  46,  18, 
+    244, 101,  77, 105,  99, 114, 
+    111, 115, 111, 102, 116,  32, 
+     40,  82,  41,  32,  72,  76, 
+     83,  76,  32,  83, 104,  97, 
+    100, 101, 114,  32,  67, 111, 
+    109, 112, 105, 108, 101, 114, 
+     32,  49,  48,  46,  49,   0, 
+      0,   0,  66,   0,  61,  17, 
+      1, 104, 108, 115, 108,  70, 
+    108,  97, 103, 115,   0,  48, 
+    120,  53,   0, 104, 108, 115, 
+    108,  84,  97, 114, 103, 101, 
+    116,   0, 118, 115,  95,  53, 
+     95,  48,   0, 104, 108, 115, 
+    108,  69, 110, 116, 114, 121, 
+      0,  84, 101, 120, 116, 117, 
+    114, 101,  86, 101, 114, 116, 
+    101, 120,  83, 104,  97, 100, 
+    101, 114,   0,   0,  58,   0, 
+     16,  17,   0,   0,   0,   0, 
+    100,   5,   0,   0,   0,   0, 
+      0,   0,  44,   3,   0,   0, 
+      0,   0,   0,   0,  44,   3, 
+      0,   0,   9,  16,   0,   0, 
     152,   0,   0,   0,   1,   0, 
-     44,   3,  64,   0,   0,   0, 
-     22,   0,  80,  17,   0,   0, 
-      5,   0,  12,   0,   4,   0, 
-    140,   1,   0,   0,   1,   0, 
-    100,   1,  28,   0,   0,   0, 
-     74,   0,  62,  17,   8,  16, 
-      0,   0, 136,   0,  60,  84, 
-    101, 120, 116, 117, 114, 101, 
-     86, 101, 114, 116, 101, 120, 
-     83, 104,  97, 100, 101, 114, 
-     32, 114, 101, 116, 117, 114, 
-    110,  32, 118,  97, 108, 117, 
-    101,  62,   0,   0,   0,   0, 
+    160,  84, 101, 120, 116, 117, 
+    114, 101,  86, 101, 114, 116, 
+    101, 120,  83, 104,  97, 100, 
+    101, 114,   0,   0,  46,   0, 
+     62,  17,   4,  16,   0,   0, 
+      9,   0, 105, 110, 112, 117, 
+    116,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     40,   0,   4,   0, 152,   0, 
-      0,   0,   1,   0,  44,   3, 
-     48,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     44,   0,   4,   0, 152,   0, 
+     80,  17,   1,   0,   5,   0, 
+      0,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     52,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     48,   0,   4,   0, 152,   0, 
+      0,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      4,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     56,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     32,   0,   4,   0, 152,   0, 
+      4,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+      8,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     32,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     36,   0,   4,   0, 152,   0, 
+      8,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     12,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     36,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
+     12,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
      16,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
      16,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
+     80,  17,   1,   0,   5,   0, 
      20,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
      20,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
+     80,  17,   1,   0,   5,   0, 
      24,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     24,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
+     32,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
      28,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     28,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-      0,   0,   4,   0, 152,   0, 
-      0,   0,   1,   0,  44,   3, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-      4,   0,   4,   0, 152,   0, 
-      0,   0,   1,   0,  44,   3, 
-      4,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-      8,   0,   4,   0, 152,   0, 
+     36,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     32,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-      8,   0,   0,   0,  22,   0, 
-     80,  17,   2,   0,   5,   0, 
-     12,   0,   4,   0, 152,   0, 
+     40,   0,   0,   0,  22,   0, 
+     80,  17,   1,   0,   5,   0, 
+     36,   0,   4,   0, 152,   0, 
       0,   0,   1,   0,  44,   3, 
-     12,   0,   0,   0,  46,   0, 
-     62,  17,   7,  16,   0,   0, 
-      8,   0, 111, 117, 116, 112, 
-    117, 116,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     40,   0,   4,   0, 120,   1, 
-      0,   0,   1,   0,  76,   2, 
-      0,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     44,   0,   4,   0, 120,   1, 
-      0,   0,   1,   0,  76,   2, 
-      4,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     48,   0,   4,   0, 120,   1, 
-      0,   0,   1,   0,  76,   2, 
-      8,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     32,   0,   4,   0, 160,   1, 
-      0,   0,   1,   0,  36,   2, 
-     32,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     36,   0,   4,   0, 160,   1, 
-      0,   0,   1,   0,  36,   2, 
-     36,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      0,   0,   4,   0, 248,   1, 
-      0,   0,   1,   0, 204,   1, 
      48,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      4,   0,   4,   0,  32,   2, 
-      0,   0,   1,   0, 164,   1, 
-     52,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-      8,   0,   4,   0,  72,   2, 
-      0,   0,   1,   0, 124,   1, 
-     56,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     12,   0,   4,   0, 112,   2, 
-      0,   0,   1,   0,  84,   1, 
-     60,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     16,   0,   4,   0, 144,   2, 
-      0,   0,   1,   0, 128,   0, 
-     16,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     20,   0,   4,   0, 176,   2, 
-      0,   0,   1,   0, 128,   0, 
-     20,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     24,   0,   4,   0, 208,   2, 
-      0,   0,   1,   0, 128,   0, 
-     24,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     28,   0,   4,   0, 240,   2, 
-      0,   0,   1,   0, 128,   0, 
-     28,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     16,   0,   4,   0,  16,   3, 
-      0,   0,   1,   0, 180,   0, 
+     80,  17,   1,   0,   5,   0, 
+     40,   0,   4,   0, 152,   0, 
+      0,   0,   1,   0,  44,   3, 
      64,   0,   0,   0,  22,   0, 
      80,  17,   0,   0,   5,   0, 
-     20,   0,   4,   0,  48,   3, 
-      0,   0,   1,   0, 148,   0, 
-     68,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     24,   0,   4,   0,  80,   3, 
-      0,   0,   1,   0, 116,   0, 
-     72,   0,   0,   0,  22,   0, 
-     80,  17,   0,   0,   5,   0, 
-     28,   0,   4,   0, 112,   3, 
-      0,   0,   1,   0,  84,   0, 
-     76,   0,   0,   0,   2,   0, 
-      6,   0, 244,   0,   0,   0, 
-     24,   0,   0,   0,   1,   0, 
-      0,   0,  16,   1, 221, 122, 
-    119,  80, 199,  74, 233, 197, 
-     53,  44, 206, 105, 247, 167, 
-      8, 234,   0,   0, 242,   0, 
-      0,   0, 184,   2,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
-      1,   0, 196,   3,   0,   0, 
-      0,   0,   0,   0,  56,   0, 
-      0,   0, 172,   2,   0,   0, 
-    152,   0,   0,   0,  43,   0, 
-      0, 128, 152,   0,   0,   0, 
-     43,   0,   0,   0, 184,   0, 
+     12,   0,   4,   0, 140,   1, 
+      0,   0,   1,   0, 100,   1, 
+     28,   0,   0,   0,  74,   0, 
+     62,  17,   8,  16,   0,   0, 
+    136,   0,  60,  84, 101, 120, 
+    116, 117, 114, 101,  86, 101, 
+    114, 116, 101, 120,  83, 104, 
+     97, 100, 101, 114,  32, 114, 
+    101, 116, 117, 114, 110,  32, 
+    118,  97, 108, 117, 101,  62, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  40,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  48,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  44,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  52,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  48,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  56,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  32,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  32,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  36,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  36,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  16,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  16,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  20,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  20,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  24,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  24,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  28,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  28,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,   0,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,   4,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,   4,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,   8,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,   8,   0, 
+      0,   0,  22,   0,  80,  17, 
+      2,   0,   5,   0,  12,   0, 
+      4,   0, 152,   0,   0,   0, 
+      1,   0,  44,   3,  12,   0, 
+      0,   0,  46,   0,  62,  17, 
+      7,  16,   0,   0,   8,   0, 
+    111, 117, 116, 112, 117, 116, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  40,   0, 
+      4,   0, 120,   1,   0,   0, 
+      1,   0,  76,   2,   0,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  44,   0, 
+      4,   0, 120,   1,   0,   0, 
+      1,   0,  76,   2,   4,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  48,   0, 
+      4,   0, 120,   1,   0,   0, 
+      1,   0,  76,   2,   8,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  32,   0, 
+      4,   0, 160,   1,   0,   0, 
+      1,   0,  36,   2,  32,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  36,   0, 
+      4,   0, 160,   1,   0,   0, 
+      1,   0,  36,   2,  36,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0, 248,   1,   0,   0, 
+      1,   0, 204,   1,  48,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   4,   0, 
+      4,   0,  32,   2,   0,   0, 
+      1,   0, 164,   1,  52,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,   8,   0, 
+      4,   0,  72,   2,   0,   0, 
+      1,   0, 124,   1,  56,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  12,   0, 
+      4,   0, 112,   2,   0,   0, 
+      1,   0,  84,   1,  60,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  16,   0, 
+      4,   0, 144,   2,   0,   0, 
+      1,   0, 128,   0,  16,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  20,   0, 
+      4,   0, 176,   2,   0,   0, 
+      1,   0, 128,   0,  20,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  24,   0, 
+      4,   0, 208,   2,   0,   0, 
+      1,   0, 128,   0,  24,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  28,   0, 
+      4,   0, 240,   2,   0,   0, 
+      1,   0, 128,   0,  28,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  16,   0, 
+      4,   0,  16,   3,   0,   0, 
+      1,   0, 180,   0,  64,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  20,   0, 
+      4,   0,  48,   3,   0,   0, 
+      1,   0, 148,   0,  68,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  24,   0, 
+      4,   0,  80,   3,   0,   0, 
+      1,   0, 116,   0,  72,   0, 
+      0,   0,  22,   0,  80,  17, 
+      0,   0,   5,   0,  28,   0, 
+      4,   0, 112,   3,   0,   0, 
+      1,   0,  84,   0,  76,   0, 
+      0,   0,   2,   0,   6,   0, 
+    244,   0,   0,   0,  24,   0, 
+      0,   0,   1,   0,   0,   0, 
+     16,   1, 221, 122, 119,  80, 
+    199,  74, 233, 197,  53,  44, 
+    206, 105, 247, 167,   8, 234, 
+      0,   0, 242,   0,   0,   0, 
+    184,   2,   0,   0,   0,   0, 
+      0,   0,   1,   0,   1,   0, 
+    196,   3,   0,   0,   0,   0, 
+      0,   0,  56,   0,   0,   0, 
+    172,   2,   0,   0, 152,   0, 
       0,   0,  43,   0,   0, 128, 
-    184,   0,   0,   0,  43,   0, 
-      0,   0, 220,   0,   0,   0, 
-     43,   0,   0, 128, 220,   0, 
+    152,   0,   0,   0,  43,   0, 
+      0,   0, 184,   0,   0,   0, 
+     43,   0,   0, 128, 184,   0, 
       0,   0,  43,   0,   0,   0, 
-      4,   1,   0,   0,  43,   0, 
-      0, 128,   4,   1,   0,   0, 
-     43,   0,   0,   0,  44,   1, 
+    220,   0,   0,   0,  43,   0, 
+      0, 128, 220,   0,   0,   0, 
+     43,   0,   0,   0,   4,   1, 
       0,   0,  43,   0,   0, 128, 
-     44,   1,   0,   0,  43,   0, 
-      0,   0,  72,   1,   0,   0, 
-     43,   0,   0, 128,  72,   1, 
+      4,   1,   0,   0,  43,   0, 
+      0,   0,  44,   1,   0,   0, 
+     43,   0,   0, 128,  44,   1, 
       0,   0,  43,   0,   0,   0, 
+     72,   1,   0,   0,  43,   0, 
+      0, 128,  72,   1,   0,   0, 
+     43,   0,   0,   0,  92,   1, 
+      0,   0,  43,   0,   0, 128, 
      92,   1,   0,   0,  43,   0, 
-      0, 128,  92,   1,   0,   0, 
-     43,   0,   0,   0, 120,   1, 
-      0,   0,  46,   0,   0, 128, 
-    120,   1,   0,   0,  46,   0, 
-      0,   0, 140,   1,   0,   0, 
-     49,   0,   0, 128, 140,   1, 
-      0,   0,  49,   0,   0,   0, 
-    160,   1,   0,   0,  52,   0, 
-      0, 128, 160,   1,   0,   0, 
-     52,   0,   0,   0, 192,   1, 
+      0,   0, 120,   1,   0,   0, 
+     46,   0,   0, 128, 120,   1, 
+      0,   0,  46,   0,   0,   0, 
+    140,   1,   0,   0,  49,   0, 
+      0, 128, 140,   1,   0,   0, 
+     49,   0,   0,   0, 160,   1, 
       0,   0,  52,   0,   0, 128, 
-    192,   1,   0,   0,  52,   0, 
-      0,   0, 212,   1,   0,   0, 
-     52,   0,   0, 128, 212,   1, 
+    160,   1,   0,   0,  52,   0, 
+      0,   0, 192,   1,   0,   0, 
+     52,   0,   0, 128, 192,   1, 
       0,   0,  52,   0,   0,   0, 
-    248,   1,   0,   0,  52,   0, 
-      0, 128, 248,   1,   0,   0, 
-     52,   0,   0,   0,  32,   2, 
+    212,   1,   0,   0,  52,   0, 
+      0, 128, 212,   1,   0,   0, 
+     52,   0,   0,   0, 248,   1, 
       0,   0,  52,   0,   0, 128, 
-     32,   2,   0,   0,  52,   0, 
-      0,   0,  72,   2,   0,   0, 
-     52,   0,   0, 128,  72,   2, 
+    248,   1,   0,   0,  52,   0, 
+      0,   0,  32,   2,   0,   0, 
+     52,   0,   0, 128,  32,   2, 
       0,   0,  52,   0,   0,   0, 
-    112,   2,   0,   0,  53,   0, 
-      0, 128, 112,   2,   0,   0, 
-     53,   0,   0,   0, 144,   2, 
+     72,   2,   0,   0,  52,   0, 
+      0, 128,  72,   2,   0,   0, 
+     52,   0,   0,   0, 112,   2, 
       0,   0,  53,   0,   0, 128, 
-    144,   2,   0,   0,  53,   0, 
-      0,   0, 176,   2,   0,   0, 
-     53,   0,   0, 128, 176,   2, 
+    112,   2,   0,   0,  53,   0, 
+      0,   0, 144,   2,   0,   0, 
+     53,   0,   0, 128, 144,   2, 
       0,   0,  53,   0,   0,   0, 
+    176,   2,   0,   0,  53,   0, 
+      0, 128, 176,   2,   0,   0, 
+     53,   0,   0,   0, 208,   2, 
+      0,   0,  53,   0,   0, 128, 
     208,   2,   0,   0,  53,   0, 
-      0, 128, 208,   2,   0,   0, 
-     53,   0,   0,   0, 240,   2, 
-      0,   0,  54,   0,   0, 128, 
-    240,   2,   0,   0,  54,   0, 
-      0,   0,  16,   3,   0,   0, 
-     54,   0,   0, 128,  16,   3, 
+      0,   0, 240,   2,   0,   0, 
+     54,   0,   0, 128, 240,   2, 
       0,   0,  54,   0,   0,   0, 
-     48,   3,   0,   0,  54,   0, 
-      0, 128,  48,   3,   0,   0, 
-     54,   0,   0,   0,  80,   3, 
+     16,   3,   0,   0,  54,   0, 
+      0, 128,  16,   3,   0,   0, 
+     54,   0,   0,   0,  48,   3, 
       0,   0,  54,   0,   0, 128, 
-     80,   3,   0,   0,  54,   0, 
-      0,   0, 112,   3,   0,   0, 
-     56,   0,   0, 128, 112,   3, 
-      0,   0,  56,   0,   0,   0, 
-    132,   3,   0,   0,  56,   0, 
-      0, 128, 132,   3,   0,   0, 
-     56,   0,   0,   0, 152,   3, 
+     48,   3,   0,   0,  54,   0, 
+      0,   0,  80,   3,   0,   0, 
+     54,   0,   0, 128,  80,   3, 
+      0,   0,  54,   0,   0,   0, 
+    112,   3,   0,   0,  56,   0, 
+      0, 128, 112,   3,   0,   0, 
+     56,   0,   0,   0, 132,   3, 
       0,   0,  56,   0,   0, 128, 
-    152,   3,   0,   0,  56,   0, 
-      0,   0, 172,   3,   0,   0, 
-     56,   0,   0, 128, 172,   3, 
+    132,   3,   0,   0,  56,   0, 
+      0,   0, 152,   3,   0,   0, 
+     56,   0,   0, 128, 152,   3, 
       0,   0,  56,   0,   0,   0, 
+    172,   3,   0,   0,  56,   0, 
+      0, 128, 172,   3,   0,   0, 
+     56,   0,   0,   0, 192,   3, 
+      0,   0,  56,   0,   0, 128, 
     192,   3,   0,   0,  56,   0, 
-      0, 128, 192,   3,   0,   0, 
-     56,   0,   0,   0,   2,   0, 
-     86,   0,  56,   0,  83,   0, 
+      0,   0,   2,   0,  86,   0, 
+     56,   0,  83,   0,   2,   0, 
+     86,   0,  28,   0,  84,   0, 
       2,   0,  86,   0,  28,   0, 
      84,   0,   2,   0,  86,   0, 
      28,   0,  84,   0,   2,   0, 
-     86,   0,  28,   0,  84,   0, 
+     86,   0,  18,   0,  85,   0, 
       2,   0,  86,   0,  18,   0, 
      85,   0,   2,   0,  86,   0, 
      18,   0,  85,   0,   2,   0, 
-     86,   0,  18,   0,  85,   0, 
-      2,   0,  25,   0,   2,   0, 
-     24,   0,   2,   0,  24,   0, 
-      2,   0,  23,   0,   2,   0, 
-     69,   0,  40,   0,  67,   0, 
+     25,   0,   2,   0,  24,   0, 
+      2,   0,  24,   0,   2,   0, 
+     23,   0,   2,   0,  69,   0, 
+     40,   0,  67,   0,   2,   0, 
+     69,   0,  20,   0,  68,   0, 
       2,   0,  69,   0,  20,   0, 
      68,   0,   2,   0,  69,   0, 
      20,   0,  68,   0,   2,   0, 
      69,   0,  20,   0,  68,   0, 
       2,   0,  69,   0,  20,   0, 
-     68,   0,   2,   0,  69,   0, 
-     20,   0,  68,   0,   2,   0, 
+     68,   0,   2,   0,  46,   0, 
+     20,   0,  45,   0,   2,   0, 
      46,   0,  20,   0,  45,   0, 
       2,   0,  46,   0,  20,   0, 
      45,   0,   2,   0,  46,   0, 
      20,   0,  45,   0,   2,   0, 
-     46,   0,  20,   0,  45,   0, 
+     52,   0,  20,   0,  51,   0, 
       2,   0,  52,   0,  20,   0, 
      51,   0,   2,   0,  52,   0, 
      20,   0,  51,   0,   2,   0, 
      52,   0,  20,   0,  51,   0, 
-      2,   0,  52,   0,  20,   0, 
-     51,   0,   2,   0,  15,   0, 
       2,   0,  15,   0,   2,   0, 
      15,   0,   2,   0,  15,   0, 
       2,   0,  15,   0,   2,   0, 
      15,   0,   2,   0,  15,   0, 
       2,   0,  15,   0,   2,   0, 
      15,   0,   2,   0,  15,   0, 
-    246,   0,   0,   0,   4,   0, 
+      2,   0,  15,   0, 246,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0,  16,   0, 
       0,   0,   0,   0,   0,   0, 
-     16,   0,   0,   0,   0,   0, 
-      0,   0,  36,   0,   0,   0, 
-     72,   0,   0,   0, 100,   0, 
+     36,   0,   0,   0,  72,   0, 
+      0,   0, 100,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2160,70 +2075,72 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  11, 202,  49,   1, 
-     56,   0,   0,   0,   0,  16, 
-      0,   0,  15,  16,   0,   0, 
-    185,   1,   0,   0,  11,   0, 
-    255, 255,   4,   0,   0,   0, 
-    255, 255,   3,   0,   0,   0, 
-      0,   0,  60,   0,   0,   0, 
-     60,   0,   0,   0,   8,   0, 
-      0,   0,  68,   0,   0,   0, 
-      0,   0,   0,   0,  19,   0, 
-     27,  21,  64,   0,   0,   0, 
-      4,   0,   0,   0,  16,   0, 
-    102, 108, 111,  97, 116,  52, 
-      0,  19,   0,  27,  21,  64, 
-      0,   0,   0,   2,   0,   0, 
-      0,   8,   0, 102, 108, 111, 
-     97, 116,  50,   0,  19,   0, 
-     27,  21,  64,   0,   0,   0, 
-      3,   0,   0,   0,  12,   0, 
-    102, 108, 111,  97, 116,  51, 
-      0,  94,   0,   3,  18,  13, 
-     21,   3,   0,   0,  16,   0, 
-      0,   0,   0, 112, 111, 115, 
-    105, 116, 105, 111, 110,   0, 
-    241,  13,  21,   3,   0,   1, 
-     16,   0,   0,  16,   0, 116, 
-    101, 120,   0, 242, 241,  13, 
-     21,   3,   0,   2,  16,   0, 
-      0,  24,   0, 110, 111, 114, 
-    109,  97, 108,   0, 243, 242, 
-    241,  13,  21,   3,   0, 117, 
-      0,   0,   0,  36,   0, 107, 
-    110, 111,  99, 104, 101, 110, 
-      0, 242, 241,  13,  21,   3, 
-      0, 117,   0,   0,   0,  40, 
-      0, 105, 100,   0, 243, 242, 
-    241,  36,   0,   5,  21,   5, 
-      0,   0,   0,   3,  16,   0, 
+     11, 202,  49,   1,  56,   0, 
+      0,   0,   0,  16,   0,   0, 
+     15,  16,   0,   0, 200,   1, 
+      0,   0,  10,   0, 255, 255, 
+      4,   0,   0,   0, 255, 255, 
+      3,   0,   0,   0,   0,   0, 
+     60,   0,   0,   0,  60,   0, 
+      0,   0,   8,   0,   0,   0, 
+     68,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,  27,  21, 
+     64,   0,   0,   0,   4,   0, 
+      0,   0,  16,   0, 102, 108, 
+    111,  97, 116,  52,   0, 243, 
+    242, 241,  22,   0,  27,  21, 
+     64,   0,   0,   0,   2,   0, 
+      0,   0,   8,   0, 102, 108, 
+    111,  97, 116,  50,   0, 243, 
+    242, 241,  22,   0,  27,  21, 
+     64,   0,   0,   0,   3,   0, 
+      0,   0,  12,   0, 102, 108, 
+    111,  97, 116,  51,   0, 243, 
+    242, 241,  94,   0,   3,  18, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,   0,   0, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+      0, 241,  13,  21,   3,   0, 
+      1,  16,   0,   0,  16,   0, 
+    116, 101, 120,   0, 242, 241, 
+     13,  21,   3,   0,   2,  16, 
+      0,   0,  24,   0, 110, 111, 
+    114, 109,  97, 108,   0, 243, 
+    242, 241,  13,  21,   3,   0, 
+    117,   0,   0,   0,  36,   0, 
+    107, 110, 111,  99, 104, 101, 
+    110,   0, 242, 241,  13,  21, 
+      3,   0, 117,   0,   0,   0, 
+     40,   0, 105, 100,   0, 243, 
+    242, 241,  38,   0,   5,  21, 
+      5,   0,   0,   0,   3,  16, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,  44,   0,  86, 
-    101, 114, 116, 101, 120,  73, 
+      0,   0,   0,   0,  44,   0, 
+     86, 101, 114, 116, 101, 120, 
+     73, 110, 112, 117, 116,  84, 
+    121, 112, 101,   0, 242, 241, 
+     10,   0,   1,  18,   1,   0, 
+      0,   0,   4,  16,   0,   0, 
+     78,   0,   3,  18,  13,  21, 
+      3,   0,   0,  16,   0,   0, 
+      0,   0, 119, 111, 114, 108, 
+    100,  80, 111, 115,   0, 241, 
+     13,  21,   3,   0,   0,  16, 
+      0,   0,  16,   0, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+      0, 241,  13,  21,   3,   0, 
+      1,  16,   0,   0,  32,   0, 
+    116, 101, 120,   0, 242, 241, 
+     13,  21,   3,   0,   2,  16, 
+      0,   0,  40,   0, 110, 111, 
+    114, 109,  97, 108,   0, 243, 
+    242, 241,  38,   0,   5,  21, 
+      4,   0,   0,   0,   6,  16, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  52,   0, 
+     80, 105, 120, 101, 108,  73, 
     110, 112, 117, 116,  84, 121, 
-    112, 101,   0,  10,   0,   1, 
-     18,   1,   0,   0,   0,   4, 
-     16,   0,   0,  78,   0,   3, 
-     18,  13,  21,   3,   0,   0, 
-     16,   0,   0,   0,   0, 119, 
-    111, 114, 108, 100,  80, 111, 
-    115,   0, 241,  13,  21,   3, 
-      0,   0,  16,   0,   0,  16, 
-      0, 112, 111, 115, 105, 116, 
-    105, 111, 110,   0, 241,  13, 
-     21,   3,   0,   1,  16,   0, 
-      0,  32,   0, 116, 101, 120, 
-      0, 242, 241,  13,  21,   3, 
-      0,   2,  16,   0,   0,  40, 
-      0, 110, 111, 114, 109,  97, 
-    108,   0, 243, 242, 241,  35, 
-      0,   5,  21,   4,   0,   0, 
-      0,   6,  16,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,  52,   0,  80, 105, 120, 
-    101, 108,  73, 110, 112, 117, 
-    116,  84, 121, 112, 101,   0, 
+    112, 101,   0, 243, 242, 241, 
      10,   0,  24,  21,   7,  16, 
       0,   0,   1,   0,   1,   0, 
      14,   0,   8,  16,   8,  16, 
@@ -2236,22 +2153,19 @@ const BYTE UIVertexShader[] =
      97, 116,  52, 120,  52,   0, 
      10,   0,  24,  21,  10,  16, 
       0,   0,   1,   0,   1,   0, 
-     17,   0,  22,  21,  11,  16, 
+     18,   0,  22,  21,  11,  16, 
       0,   0,  34,   0,   0,   0, 
      64,   0,   0,   0,   0,  32, 
-      0,  10,   0,  24,  21,  12, 
-     16,   0,   0,   1,   0,   0, 
-      2,  10,   0,  24,  21,  11, 
-     16,   0,   0,   1,   0,   0, 
-      2,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  11, 202, 
-     49,   1,  56,   0,   0,   0, 
-      0,  16,   0,   0,   0,  16, 
-      0,   0,   0,   0,   0,   0, 
-     13,   0, 255, 255,   4,   0, 
-      0,   0, 255, 255,   3,   0, 
-      0,   0,   0,   0,   0,   0, 
+      0, 241,  10,   0,  24,  21, 
+     12,  16,   0,   0,   1,   0, 
+      0,   2,  10,   0,  24,  21, 
+     11,  16,   0,   0,   1,   0, 
+      0,   2,  11, 202,  49,   1, 
+     56,   0,   0,   0,   0,  16, 
+      0,   0,   0,  16,   0,   0, 
+      0,   0,   0,   0,  11,   0, 
+    255, 255,   4,   0,   0,   0, 
+    255, 255,   3,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2331,6 +2245,7 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -2340,11 +2255,10 @@ const BYTE UIVertexShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  13,  10,  47, 
-     47,  32,  86, 101, 114, 116, 
-    101, 120,  32,  83, 104,  97, 
-    100, 101, 114,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
+     47,  13,  10,  47,  47,  32, 
+     86, 101, 114, 116, 101, 120, 
+     32,  83, 104,  97, 100, 101, 
+    114,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2354,7 +2268,8 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  13,  10,  47,  47,  47, 
+     32,  32,  32,  32,  32,  13, 
+     10,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
@@ -2367,21 +2282,20 @@ const BYTE UIVertexShader[] =
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
      47,  47,  47,  47,  47,  47, 
-     47,  47,  47,  47,  47,  13, 
-     10,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32,  84, 101, 
-    120, 116, 117, 114, 101,  86, 
-    101, 114, 116, 101, 120,  83, 
-    104,  97, 100, 101, 114,  40, 
-     86, 101, 114, 116, 101, 120, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 105, 110, 
-    112, 117, 116,  41,  13,  10, 
-    123,  13,  10,   9,  47,  47, 
-    114, 101, 116, 117, 114, 110, 
-     32, 105, 110, 112, 117, 116, 
-     59,  32,  32,  32,  32,  32, 
+     47,  47,  47,  13,  10,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32,  84, 101, 120, 116, 
+    117, 114, 101,  86, 101, 114, 
+    116, 101, 120,  83, 104,  97, 
+    100, 101, 114,  40,  86, 101, 
+    114, 116, 101, 120,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 105, 110, 112, 117, 
+    116,  41,  13,  10, 123,  13, 
+     10,   9,  47,  47, 114, 101, 
+    116, 117, 114, 110,  32, 105, 
+    110, 112, 117, 116,  59,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
@@ -2392,120 +2306,119 @@ const BYTE UIVertexShader[] =
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
      32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-      9,  80, 105, 120, 101, 108, 
-     73, 110, 112, 117, 116,  84, 
-    121, 112, 101,  32, 111, 117, 
-    116, 112, 117, 116,  59,  13, 
-     10,   9, 111, 117, 116, 112, 
-    117, 116,  46, 110, 111, 114, 
-    109,  97, 108,  32,  61,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,   9,  80, 
+    105, 120, 101, 108,  73, 110, 
+    112, 117, 116,  84, 121, 112, 
+    101,  32, 111, 117, 116, 112, 
+    117, 116,  59,  13,  10,   9, 
+    111, 117, 116, 112, 117, 116, 
+     46, 110, 111, 114, 109,  97, 
+    108,  32,  61,  32, 110, 111, 
+    114, 109,  97, 108, 105, 122, 
+    101,  40, 109, 117, 108,  40, 
+    105, 110, 112, 117, 116,  46, 
     110, 111, 114, 109,  97, 108, 
-    105, 122, 101,  40, 109, 117, 
-    108,  40, 105, 110, 112, 117, 
-    116,  46, 110, 111, 114, 109, 
-     97, 108,  44,  32,  40, 102, 
-    108, 111,  97, 116,  51, 120, 
-     51,  41, 107, 110, 111,  99, 
+     44,  32,  40, 102, 108, 111, 
+     97, 116,  51, 120,  51,  41, 
+    107, 110, 111,  99, 104, 101, 
+    110,  77,  97, 116, 114, 105, 
+    120,  91, 105, 110, 112, 117, 
+    116,  46, 107, 110, 111,  99, 
+    104, 101, 110,  93,  41,  41, 
+     59,  13,  10,  13,  10,   9, 
+     47,  47,  32,  67, 104,  97, 
+    110, 103, 101,  32, 116, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 118, 
+    101,  99, 116, 111, 114,  32, 
+    116, 111,  32,  98, 101,  32, 
+     52,  32, 117, 110, 105, 116, 
+    115,  32, 102, 111, 114,  32, 
+    112, 114, 111, 112, 101, 114, 
+     32, 109,  97, 116, 114, 105, 
+    120,  32,  99,  97, 108,  99, 
+    117, 108,  97, 116, 105, 111, 
+    110, 115,  46,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     13,  10,   9, 105, 110, 112, 
+    117, 116,  46, 112, 111, 115, 
+    105, 116, 105, 111, 110,  46, 
+    119,  32,  61,  32,  49,  46, 
+     48, 102,  59,  13,  10,  13, 
+     10,   9,  47,  47,  32,  83, 
+    116, 111, 114, 101,  32, 116, 
+    104, 101,  32, 116, 101, 120, 
+    116, 117, 114, 101,  32,  99, 
+    111, 111, 114, 100, 105, 110, 
+     97, 116, 101, 115,  32, 102, 
+    111, 114,  32, 116, 104, 101, 
+     32, 112, 105, 120, 101, 108, 
+     32, 115, 104,  97, 100, 101, 
+    114,  46,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  32,  32,  32,  32, 
+     32,  32,  13,  10,   9, 111, 
+    117, 116, 112, 117, 116,  46, 
+    116, 101, 120,  32,  61,  32, 
+    105, 110, 112, 117, 116,  46, 
+    116, 101, 120,  59,  13,  10, 
+     13,  10,   9,  47,  47,  32, 
+     67,  97, 108,  99, 117, 108, 
+     97, 116, 101,  32, 116, 104, 
+    101,  32, 112, 111, 115, 105, 
+    116, 105, 111, 110,  32, 111, 
+    102,  32, 116, 104, 101,  32, 
+    118, 101, 114, 116, 101, 120, 
+     32,  97, 103,  97, 105, 110, 
+    115, 116,  32, 116, 104, 101, 
+     32, 119, 111, 114, 108, 100, 
+     44,  32, 118, 105, 101, 119, 
+     44,  32,  97, 110, 100,  32, 
+    112, 114, 111, 106, 101,  99, 
+    116, 105, 111, 110,  32, 109, 
+     97, 116, 114, 105,  99, 101, 
+    115,  46,  32,  13,  10,   9, 
+    111, 117, 116, 112, 117, 116, 
+     46, 119, 111, 114, 108, 100, 
+     80, 111, 115,  32,  61,  32, 
+    109, 117, 108,  40, 105, 110, 
+    112, 117, 116,  46, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     44,  32, 107, 110, 111,  99, 
     104, 101, 110,  77,  97, 116, 
     114, 105, 120,  91, 105, 110, 
     112, 117, 116,  46, 107, 110, 
     111,  99, 104, 101, 110,  93, 
-     41,  41,  59,  13,  10,  13, 
-     10,   9,  47,  47,  32,  67, 
-    104,  97, 110, 103, 101,  32, 
-    116, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 118, 101,  99, 116, 111, 
-    114,  32, 116, 111,  32,  98, 
-    101,  32,  52,  32, 117, 110, 
-    105, 116, 115,  32, 102, 111, 
-    114,  32, 112, 114, 111, 112, 
-    101, 114,  32, 109,  97, 116, 
-    114, 105, 120,  32,  99,  97, 
-    108,  99, 117, 108,  97, 116, 
-    105, 111, 110, 115,  46,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  13,  10,   9, 105, 
-    110, 112, 117, 116,  46, 112, 
-    111, 115, 105, 116, 105, 111, 
-    110,  46, 119,  32,  61,  32, 
-     49,  46,  48, 102,  59,  13, 
-     10,  13,  10,   9,  47,  47, 
-     32,  83, 116, 111, 114, 101, 
-     32, 116, 104, 101,  32, 116, 
-    101, 120, 116, 117, 114, 101, 
-     32,  99, 111, 111, 114, 100, 
-    105, 110,  97, 116, 101, 115, 
-     32, 102, 111, 114,  32, 116, 
-    104, 101,  32, 112, 105, 120, 
-    101, 108,  32, 115, 104,  97, 
-    100, 101, 114,  46,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  32,  32, 
-     32,  32,  32,  32,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 116, 101, 120,  32, 
-     61,  32, 105, 110, 112, 117, 
-    116,  46, 116, 101, 120,  59, 
-     13,  10,  13,  10,   9,  47, 
-     47,  32,  67,  97, 108,  99, 
-    117, 108,  97, 116, 101,  32, 
-    116, 104, 101,  32, 112, 111, 
-    115, 105, 116, 105, 111, 110, 
-     32, 111, 102,  32, 116, 104, 
-    101,  32, 118, 101, 114, 116, 
-    101, 120,  32,  97, 103,  97, 
-    105, 110, 115, 116,  32, 116, 
-    104, 101,  32, 119, 111, 114, 
-    108, 100,  44,  32, 118, 105, 
-    101, 119,  44,  32,  97, 110, 
-    100,  32, 112, 114, 111, 106, 
-    101,  99, 116, 105, 111, 110, 
-     32, 109,  97, 116, 114, 105, 
-     99, 101, 115,  46,  32,  13, 
-     10,   9, 111, 117, 116, 112, 
-    117, 116,  46, 119, 111, 114, 
-    108, 100,  80, 111, 115,  32, 
-     61,  32, 109, 117, 108,  40, 
-    105, 110, 112, 117, 116,  46, 
-    112, 111, 115, 105, 116, 105, 
-    111, 110,  44,  32, 107, 110, 
-    111,  99, 104, 101, 110,  77, 
-     97, 116, 114, 105, 120,  91, 
-    105, 110, 112, 117, 116,  46, 
-    107, 110, 111,  99, 104, 101, 
-    110,  93,  41,  59,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  61, 
-     32, 109, 117, 108,  40, 111, 
+     41,  59,  13,  10,   9, 111, 
     117, 116, 112, 117, 116,  46, 
-    119, 111, 114, 108, 100,  80, 
-    111, 115,  44,  32, 118, 105, 
-    101, 119,  41,  59,  13,  10, 
-      9, 111, 117, 116, 112, 117, 
-    116,  46, 112, 111, 115, 105, 
-    116, 105, 111, 110,  32,  61, 
-     32, 109, 117, 108,  40, 111, 
+    112, 111, 115, 105, 116, 105, 
+    111, 110,  32,  61,  32, 109, 
+    117, 108,  40, 111, 117, 116, 
+    112, 117, 116,  46, 119, 111, 
+    114, 108, 100,  80, 111, 115, 
+     44,  32, 118, 105, 101, 119, 
+     41,  59,  13,  10,   9, 111, 
     117, 116, 112, 117, 116,  46, 
     112, 111, 115, 105, 116, 105, 
-    111, 110,  44,  32, 112, 114, 
-    111, 106, 101,  99, 116, 105, 
-    111, 110,  41,  59,  13,  10, 
-     13,  10,   9, 114, 101, 116, 
-    117, 114, 110,  32, 111, 117, 
-    116, 112, 117, 116,  59,  13, 
-     10, 125,   0,   7,   0,   0, 
-      0,   0,   0,   0,   0,  85, 
-      0,   0,   0,   0,   0,   0, 
-      0,   1,   0,   0,   0,  86, 
-      0,   0,   0,   0,   0,   0, 
-      0, 170,   0,   0,   0,   4, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
+    111, 110,  32,  61,  32, 109, 
+    117, 108,  40, 111, 117, 116, 
+    112, 117, 116,  46, 112, 111, 
+    115, 105, 116, 105, 111, 110, 
+     44,  32, 112, 114, 111, 106, 
+    101,  99, 116, 105, 111, 110, 
+     41,  59,  13,  10,  13,  10, 
+      9, 114, 101, 116, 117, 114, 
+    110,  32, 111, 117, 116, 112, 
+    117, 116,  59,  13,  10, 125, 
+      0,   7,   0,   0,   0,   0, 
+      0,   0,   0,  85,   0,   0, 
+      0,   0,   0,   0,   0,   1, 
+      0,   0,   0,  86,   0,   0, 
+      0,   0,   0,   0,   0, 170, 
+      0,   0,   0,   4,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2587,13 +2500,15 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     68,  51,  68,  83,  72,  68, 
-     82,   0, 196,   3,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  68,  51, 
+     68,  83,  72,  68,  82,   0, 
+    196,   3,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     32,   0,   0,  96,   0,   0, 
+      0,   0,   0,   0,  32,   0, 
+      0,  96,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2672,31 +2587,29 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-     26,   9,  47, 241,  32,   0, 
-      0,   0,  20,   2,   0,   0, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,  73,   0,   0,   0, 
-      1,   0,   0,   0,  37,   0, 
+    255, 255, 255, 255,  26,   9, 
+     47, 241,  32,   0,   0,   0, 
+     20,   2,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
+     73,   0,   0,   0,   1,   0, 
+      0,   0,  37,   0,   0,   0, 
+      1,   0,   0,   0, 101,   0, 
       0,   0,   1,   0,   0,   0, 
-    101,   0,   0,   0,   1,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   2,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      2,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   1,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2713,8 +2626,8 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   4,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   4, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2739,9 +2652,9 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,   0,   4, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   4,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2767,9 +2680,10 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     12,   0,   0,   0,  24,   0, 
-      0,   0,  36,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  12,   0, 
+      0,   0,  24,   0,   0,   0, 
+     36,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2843,28 +2757,29 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-     34,   0,  37,  17,   0,   0, 
-      0,   0, 140,   0,   0,   0, 
-      1,   0,  84, 101, 120, 116, 
-    117, 114, 101,  86, 101, 114, 
-    116, 101, 120,  83, 104,  97, 
-    100, 101, 114,   0,   0,   0, 
-     34,   0,  81,  17,  13,  16, 
-      0,   0,   8,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 107, 110, 111,  99, 
-    104, 101, 110,  77,  97, 116, 
-    114, 105, 120,   0,   0,   0, 
-     26,   0,  81,  17,  14,  16, 
-      0,   0,   8,   0,   1,   0, 
-      0,   0, 255, 255, 255, 255, 
-    255, 255, 118, 105, 101, 119, 
-      0,   0,   0,   0,  30,   0, 
+      0,   0,   0,   0,  34,   0, 
+     37,  17,   0,   0,   0,   0, 
+    140,   0,   0,   0,   1,   0, 
+     84, 101, 120, 116, 117, 114, 
+    101,  86, 101, 114, 116, 101, 
+    120,  83, 104,  97, 100, 101, 
+    114,   0,   0,   0,  34,   0, 
+     81,  17,  13,  16,   0,   0, 
+      8,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255, 255, 255, 
+    107, 110, 111,  99, 104, 101, 
+    110,  77,  97, 116, 114, 105, 
+    120,   0,   0,   0,  26,   0, 
      81,  17,  14,  16,   0,   0, 
-      8,   0,   1,   0,  64,   0, 
+      8,   0,   1,   0,   0,   0, 
     255, 255, 255, 255, 255, 255, 
-    112, 114, 111, 106, 101,  99, 
-    116, 105, 111, 110,   0,   0, 
+    118, 105, 101, 119,   0,   0, 
+      0,   0,  30,   0,  81,  17, 
+     14,  16,   0,   0,   8,   0, 
+      1,   0,  64,   0, 255, 255, 
+    255, 255, 255, 255, 112, 114, 
+    111, 106, 101,  99, 116, 105, 
+    111, 110,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -2928,13 +2843,13 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  16,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,  26,   9,  47, 241, 
       0,   0,   0,   0,   0,   0, 
-    255, 255, 255, 255,  26,   9, 
-     47, 241,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3013,70 +2928,73 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255, 119,   9,  49,   1, 
-      1,   0,   0,   0,  15,   0, 
-     38, 142,  16,   0, 116, 129, 
-     17,   0, 100,   0,  92,   0, 
-      0,   0,  32,   0,   0,   0, 
-     44,   0,   0,   0,  96,   0, 
+      0,   0, 255, 255, 255, 255, 
+    119,   9,  49,   1,   1,   0, 
+      0,   0,  13,   0,  20, 142, 
+     14,   0,  20, 107,  15,   0, 
+      1,   0,  92,   0,   0,   0, 
+     32,   0,   0,   0,  44,   0, 
+      0,   0,  96,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  22,   0,   0,   0, 
+     25,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  24,   0, 
-      0,   0,  25,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+    196,   3,   0,   0,  32,   0, 
+      0,  96,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   2,   0,   9,   0, 
+    104,   5,   0,   0,   0,   0, 
+      0,   0, 236,   2,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  84, 101, 
+    120, 116, 117, 114, 101,  86, 
+    101, 114, 116, 101, 120,  83, 
+    104,  97, 100, 101, 114,   0, 
+    110, 111, 110, 101,   0,   0, 
+      0,   0,  45, 186,  46, 241, 
       1,   0,   0,   0,   0,   0, 
       0,   0, 196,   3,   0,   0, 
      32,   0,   0,  96,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   2,   0, 
-     10,   0, 104,   5,   0,   0, 
-      0,   0,   0,   0, 236,   2, 
+      2,   0,   7,   0,   0,   0, 
+      0,   0,   1,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    196,   3,   0,   0,   8,   2, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      1,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+     67,  58,  92,  85, 115, 101, 
+    114, 115,  92, 107, 111, 108, 
+    106,  97,  92,  68, 101, 115, 
+    107, 116, 111, 112,  92,  75, 
+    111, 108, 106,  97,  45,  83, 
+    116, 114, 111, 104, 109,  45, 
+     71,  97, 109, 101, 115,  92, 
+     65, 108, 108, 103, 101, 109, 
+    101, 105, 110,  92,  70, 114, 
+     97, 109, 101, 119, 111, 114, 
+    107,  92,  68,  88,  49,  49, 
+     86, 101, 114, 116, 101, 120, 
+     83, 104,  97, 100, 101, 114, 
+     46, 104, 108, 115, 108,   0, 
+    254, 239, 254, 239,   1,   0, 
       0,   0,   1,   0,   0,   0, 
+      0,   1,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255, 255,  12, 
+      0, 255, 255, 255, 255, 255, 
+    255, 255, 255, 255, 255,   0, 
       0,   0,   0,   0,   0,   0, 
-     84, 101, 120, 116, 117, 114, 
-    101,  86, 101, 114, 116, 101, 
-    120,  83, 104,  97, 100, 101, 
-    114,   0, 110, 111, 110, 101, 
-      0,   0,   0,   0,  45, 186, 
-     46, 241,   1,   0,   0,   0, 
-      0,   0,   0,   0, 196,   3, 
-      0,   0,  32,   0,   0,  96, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      2,   0,   2,   0,   7,   0, 
-      0,   0,   0,   0,   1,   0, 
-    255, 255, 255, 255,   0,   0, 
-      0,   0, 196,   3,   0,   0, 
-      8,   2,   0,   0,   0,   0, 
-      0,   0, 255, 255, 255, 255, 
-      0,   0,   0,   0, 255, 255, 
-    255, 255,   1,   0,   1,   0, 
-      0,   0,   1,   0,   0,   0, 
-      0,   0,  67,  58,  92,  85, 
-    115, 101, 114, 115,  92, 107, 
-    111, 108, 106,  97,  92,  68, 
-    101, 115, 107, 116, 111, 112, 
-     92,  75, 111, 108, 106,  97, 
-     45,  83, 116, 114, 111, 104, 
-    109,  45,  71,  97, 109, 101, 
-    115,  92,  65, 108, 108, 103, 
-    101, 109, 101, 105, 110,  92, 
-     70, 114,  97, 109, 101, 119, 
-    111, 114, 107,  92,  68,  88, 
-     49,  49,  86, 101, 114, 116, 
-    101, 120,  83, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0, 254, 239, 254, 239, 
-      1,   0,   0,   0,   1,   0, 
-      0,   0,   0,   1,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255,  14,   0, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 
-    255, 255, 255,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3095,54 +3013,49 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 148,  46, 
+     49,   1,  77, 224, 173, 104, 
+      1,   0,   0,   0, 175, 104, 
+    189,  60,  55, 199,  66,  76, 
+    173,  77,  99, 193,  35,  69, 
+     23, 180, 129,   0,   0,   0, 
+     47,  76, 105, 110, 107,  73, 
+    110, 102, 111,   0,  47, 110, 
+     97, 109, 101, 115,   0,  47, 
+    115, 114,  99,  47, 104, 101, 
+     97, 100, 101, 114,  98, 108, 
+    111,  99, 107,   0,  47, 115, 
+    114,  99,  47, 102, 105, 108, 
+    101, 115,  47,  99,  58,  92, 
+    117, 115, 101, 114, 115,  92, 
+    107, 111, 108, 106,  97,  92, 
+    100, 101, 115, 107, 116, 111, 
+    112,  92, 107, 111, 108, 106, 
+     97,  45, 115, 116, 114, 111, 
+    104, 109,  45, 103,  97, 109, 
+    101, 115,  92,  97, 108, 108, 
+    103, 101, 109, 101, 105, 110, 
+     92, 102, 114,  97, 109, 101, 
+    119, 111, 114, 107,  92, 100, 
+    120,  49,  49, 118, 101, 114, 
+    116, 101, 120, 115, 104,  97, 
+    100, 101, 114,  46, 104, 108, 
+    115, 108,   0,   4,   0,   0, 
+      0,   6,   0,   0,   0,   1, 
+      0,   0,   0,  30,   0,   0, 
+      0,   0,   0,   0,   0,  17, 
+      0,   0,   0,   7,   0,   0, 
+      0,  34,   0,   0,   0,   8, 
+      0,   0,   0,  10,   0,   0, 
+      0,   6,   0,   0,   0,   0, 
+      0,   0,   0,   5,   0,   0, 
+      0,   0,   0,   0,   0, 220, 
+     81,  51,   1,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-    148,  46,  49,   1,   7, 118, 
-     88, 104,   1,   0,   0,   0, 
-     44, 121, 113, 213,  73,   7, 
-     91,  71, 128,  68, 217, 177, 
-    225, 239,  72, 143, 156,   0, 
-      0,   0,  47,  76, 105, 110, 
-    107,  73, 110, 102, 111,   0, 
-     47,  84,  77,  67,  97,  99, 
-    104, 101,   0,  47, 110,  97, 
-    109, 101, 115,   0,  47, 115, 
-    114,  99,  47, 104, 101,  97, 
-    100, 101, 114,  98, 108, 111, 
-     99, 107,   0,  47, 115, 114, 
-     99,  47, 102, 105, 108, 101, 
-    115,  47,  99,  58,  92, 117, 
-    115, 101, 114, 115,  92, 107, 
-    111, 108, 106,  97,  92, 100, 
-    101, 115, 107, 116, 111, 112, 
-     92, 107, 111, 108, 106,  97, 
-     45, 115, 116, 114, 111, 104, 
-    109,  45, 103,  97, 109, 101, 
-    115,  92,  97, 108, 108, 103, 
-    101, 109, 101, 105, 110,  92, 
-    102, 114,  97, 109, 101, 119, 
-    111, 114, 107,  92, 100, 120, 
-     49,  49, 118, 101, 114, 116, 
-    101, 120, 115, 104,  97, 100, 
-    101, 114,  46, 104, 108, 115, 
-    108,   0,  47,  85,  68,  84, 
-     83,  82,  67,  76,  73,  78, 
-     69,  85,  78,  68,  79,  78, 
-     69,   0,   6,   0,   0,   0, 
-     10,   0,   0,   0,   1,   0, 
-      0,   0, 111,   0,   0,   0, 
-      0,   0,   0,   0, 138,   0, 
-      0,   0,  12,   0,   0,   0, 
-     26,   0,   0,   0,   8,   0, 
       0,   0,   0,   0,   0,   0, 
-      5,   0,   0,   0,  10,   0, 
-      0,   0,   6,   0,   0,   0, 
-     43,   0,   0,   0,   9,   0, 
-      0,   0,  19,   0,   0,   0, 
-      7,   0,   0,   0,   0,   0, 
-      0,   0, 220,  81,  51,   1, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3184,36 +3097,124 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,  18,   0,   0,   0, 
-     40,   0,   0,   0,   8,   1, 
-      0,   0, 241,   1,   0,   0, 
-    121,   1,   0,   0,  56,   0, 
       0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     16,   0,   0,   0,  32,   0, 
+      0,   0, 221,   0,   0,   0, 
+      0,   2,   0,   0, 119,   1, 
+      0,   0,  56,   0,   0,   0, 
       0,   0,   0,   0,  17,   8, 
       0,   0, 128,   0,   0,   0, 
      54,   7,   0,   0, 104,   8, 
       0,   0,  68,   0,   0,   0, 
-      0,   0,   0,   0,   0,   0, 
-      0,   0,  40,   0,   0,   0, 
-     68,   2,   0,   0,  44,   0, 
-      0,   0, 132,   0,   0,   0, 
-      7,   0,   0,   0,  31,   0, 
-      0,   0,  20,   0,   0,   0, 
-     30,   0,   0,   0,  21,   0, 
-      0,   0,  13,   0,   0,   0, 
-      3,   0,   0,   0,  22,   0, 
+      0,   0,   0,   0,  40,   0, 
+      0,   0,  68,   2,   0,   0, 
+     44,   0,   0,   0, 132,   0, 
+      0,   0,   3,   0,   0,   0, 
+     30,   0,   0,   0,  19,   0, 
+      0,   0,  29,   0,   0,   0, 
+     20,   0,   0,   0,  12,   0, 
+      0,   0,   6,   0,   0,   0, 
+     21,   0,   0,   0,  22,   0, 
       0,   0,  23,   0,   0,   0, 
-     24,   0,   0,   0,  14,   0, 
+     13,   0,   0,   0,   8,   0, 
       0,   0,   9,   0,   0,   0, 
      10,   0,   0,   0,  11,   0, 
-      0,   0,  12,   0,   0,   0, 
+      0,   0,  14,   0,   0,   0, 
      15,   0,   0,   0,  16,   0, 
       0,   0,  17,   0,   0,   0, 
-     18,   0,   0,   0,  19,   0, 
-      0,   0,   4,   0,   0,   0, 
+     18,   0,   0,   0,   7,   0, 
+      0,   0,  24,   0,   0,   0, 
      25,   0,   0,   0,  26,   0, 
-      0,   0,  27,   0,   0,   0, 
-     29,   0,   0,   0,  28,   0, 
+      0,   0,  28,   0,   0,   0, 
+     27,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  31,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
@@ -3269,7 +3270,6 @@ const BYTE UIVertexShader[] =
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
-      0,   0,   0,   0,  32,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0, 
       0,   0,   0,   0,   0,   0,