Move solution and projects to src

13 files changed, 7122 insertions, 0 deletions

diff --git a/src/Ryujinx.Graphics.Shader/Decoders/Block.cs b/src/Ryujinx.Graphics.Shader/Decoders/Block.cs
new file mode 100644
index 00000000..7d94e3f9
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/Block.cs
@@ -0,0 +1,168 @@
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    class PushOpInfo
+    {
+        public InstOp Op { get; }
+        public Dictionary<Block, Operand> Consumers;
+
+        public PushOpInfo(InstOp op)
+        {
+            Op = op;
+            Consumers = new Dictionary<Block, Operand>();
+        }
+    }
+
+    readonly struct SyncTarget
+    {
+        public PushOpInfo PushOpInfo { get; }
+        public int PushOpId { get; }
+
+        public SyncTarget(PushOpInfo pushOpInfo, int pushOpId)
+        {
+            PushOpInfo = pushOpInfo;
+            PushOpId = pushOpId;
+        }
+    }
+
+    class Block
+    {
+        public ulong Address { get; set; }
+        public ulong EndAddress { get; set; }
+
+        public List<Block> Predecessors { get; }
+        public List<Block> Successors { get; }
+
+        public List<InstOp> OpCodes { get; }
+        public List<PushOpInfo> PushOpCodes { get; }
+        public Dictionary<ulong, SyncTarget> SyncTargets { get; }
+
+        public Block(ulong address)
+        {
+            Address = address;
+
+            Predecessors = new List<Block>();
+            Successors = new List<Block>();
+
+            OpCodes = new List<InstOp>();
+            PushOpCodes = new List<PushOpInfo>();
+            SyncTargets = new Dictionary<ulong, SyncTarget>();
+        }
+
+        public void Split(Block rightBlock)
+        {
+            int splitIndex = BinarySearch(OpCodes, rightBlock.Address);
+
+            if (OpCodes[splitIndex].Address < rightBlock.Address)
+            {
+                splitIndex++;
+            }
+
+            int splitCount = OpCodes.Count - splitIndex;
+            if (splitCount <= 0)
+            {
+                throw new ArgumentException("Can't split at right block address.");
+            }
+
+            rightBlock.EndAddress = EndAddress;
+            rightBlock.Successors.AddRange(Successors);
+            rightBlock.Predecessors.Add(this);
+
+            EndAddress = rightBlock.Address;
+
+            Successors.Clear();
+            Successors.Add(rightBlock);
+
+            // Move ops.
+            rightBlock.OpCodes.AddRange(OpCodes.GetRange(splitIndex, splitCount));
+
+            OpCodes.RemoveRange(splitIndex, splitCount);
+
+            // Update push consumers that points to this block.
+            foreach (SyncTarget syncTarget in SyncTargets.Values)
+            {
+                PushOpInfo pushOpInfo = syncTarget.PushOpInfo;
+
+                Operand local = pushOpInfo.Consumers[this];
+                pushOpInfo.Consumers.Remove(this);
+                pushOpInfo.Consumers.Add(rightBlock, local);
+            }
+
+            foreach ((ulong  key, SyncTarget value) in SyncTargets)
+            {
+                rightBlock.SyncTargets.Add(key, value);
+            }
+
+            SyncTargets.Clear();
+
+            // Move push ops.
+            for (int i = 0; i < PushOpCodes.Count; i++)
+            {
+                if (PushOpCodes[i].Op.Address >= rightBlock.Address)
+                {
+                    int count = PushOpCodes.Count - i;
+                    rightBlock.PushOpCodes.AddRange(PushOpCodes.Skip(i));
+                    PushOpCodes.RemoveRange(i, count);
+                    break;
+                }
+            }
+        }
+
+        private static int BinarySearch(List<InstOp> opCodes, ulong address)
+        {
+            int left = 0;
+            int middle = 0;
+            int right = opCodes.Count - 1;
+
+            while (left <= right)
+            {
+                int size = right - left;
+
+                middle = left + (size >> 1);
+
+                InstOp opCode = opCodes[middle];
+
+                if (address == opCode.Address)
+                {
+                    break;
+                }
+
+                if (address < opCode.Address)
+                {
+                    right = middle - 1;
+                }
+                else
+                {
+                    left = middle + 1;
+                }
+            }
+
+            return middle;
+        }
+
+        public InstOp GetLastOp()
+        {
+            if (OpCodes.Count != 0)
+            {
+                return OpCodes[OpCodes.Count - 1];
+            }
+
+            return default;
+        }
+
+        public bool HasNext()
+        {
+            InstOp lastOp = GetLastOp();
+            return OpCodes.Count != 0 && !Decoder.IsUnconditionalBranch(ref lastOp);
+        }
+
+        public void AddPushOp(InstOp op)
+        {
+            PushOpCodes.Add(new PushOpInfo(op));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/DecodedFunction.cs b/src/Ryujinx.Graphics.Shader/Decoders/DecodedFunction.cs
new file mode 100644
index 00000000..7a172fe6
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/DecodedFunction.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    class DecodedFunction
+    {
+        private readonly HashSet<DecodedFunction> _callers;
+
+        public bool IsCompilerGenerated => Type != FunctionType.User;
+        public FunctionType Type { get; set; }
+        public int Id { get; set; }
+
+        public ulong Address { get; }
+        public Block[] Blocks { get; private set; }
+
+        public DecodedFunction(ulong address)
+        {
+            Address = address;
+            _callers = new HashSet<DecodedFunction>();
+            Type = FunctionType.User;
+            Id = -1;
+        }
+
+        public void SetBlocks(Block[] blocks)
+        {
+            if (Blocks != null)
+            {
+                throw new InvalidOperationException("Blocks have already been set.");
+            }
+
+            Blocks = blocks;
+        }
+
+        public void AddCaller(DecodedFunction caller)
+        {
+            _callers.Add(caller);
+        }
+
+        public void RemoveCaller(DecodedFunction caller)
+        {
+            if (_callers.Remove(caller) && _callers.Count == 0)
+            {
+                Type = FunctionType.Unused;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/DecodedProgram.cs b/src/Ryujinx.Graphics.Shader/Decoders/DecodedProgram.cs
new file mode 100644
index 00000000..2dd60155
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/DecodedProgram.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    readonly struct DecodedProgram : IEnumerable<DecodedFunction>
+    {
+        public DecodedFunction MainFunction { get; }
+        private readonly IReadOnlyDictionary<ulong, DecodedFunction> _functions;
+        private readonly List<DecodedFunction> _functionsWithId;
+        public int FunctionsWithIdCount => _functionsWithId.Count;
+
+        public DecodedProgram(DecodedFunction mainFunction, IReadOnlyDictionary<ulong, DecodedFunction> functions)
+        {
+            MainFunction = mainFunction;
+            _functions = functions;
+            _functionsWithId = new List<DecodedFunction>();
+        }
+
+        public DecodedFunction GetFunctionByAddress(ulong address)
+        {
+            if (_functions.TryGetValue(address, out DecodedFunction function))
+            {
+                return function;
+            }
+
+            return null;
+        }
+
+        public DecodedFunction GetFunctionById(int id)
+        {
+            if ((uint)id >= (uint)_functionsWithId.Count)
+            {
+                throw new ArgumentOutOfRangeException(nameof(id));
+            }
+
+            return _functionsWithId[id];
+        }
+
+        public void AddFunctionAndSetId(DecodedFunction function)
+        {
+            function.Id = _functionsWithId.Count;
+            _functionsWithId.Add(function);
+        }
+
+        public IEnumerator<DecodedFunction> GetEnumerator()
+        {
+            return _functions.Values.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/Decoder.cs b/src/Ryujinx.Graphics.Shader/Decoders/Decoder.cs
new file mode 100644
index 00000000..c619b9bb
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/Decoder.cs
@@ -0,0 +1,765 @@
+using Ryujinx.Graphics.Shader.Translation;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    static class Decoder
+    {
+        public static DecodedProgram Decode(ShaderConfig config, ulong startAddress)
+        {
+            Queue<DecodedFunction> functionsQueue = new Queue<DecodedFunction>();
+            Dictionary<ulong, DecodedFunction> functionsVisited = new Dictionary<ulong, DecodedFunction>();
+
+            DecodedFunction EnqueueFunction(ulong address)
+            {
+                if (!functionsVisited.TryGetValue(address, out DecodedFunction function))
+                {
+                    functionsVisited.Add(address, function = new DecodedFunction(address));
+                    functionsQueue.Enqueue(function);
+                }
+
+                return function;
+            }
+
+            DecodedFunction mainFunction = EnqueueFunction(0);
+
+            while (functionsQueue.TryDequeue(out DecodedFunction currentFunction))
+            {
+                List<Block> blocks = new List<Block>();
+                Queue<Block> workQueue = new Queue<Block>();
+                Dictionary<ulong, Block> visited = new Dictionary<ulong, Block>();
+
+                Block GetBlock(ulong blkAddress)
+                {
+                    if (!visited.TryGetValue(blkAddress, out Block block))
+                    {
+                        block = new Block(blkAddress);
+
+                        workQueue.Enqueue(block);
+                        visited.Add(blkAddress, block);
+                    }
+
+                    return block;
+                }
+
+                GetBlock(currentFunction.Address);
+
+                bool hasNewTarget;
+
+                do
+                {
+                    while (workQueue.TryDequeue(out Block currBlock))
+                    {
+                        // Check if the current block is inside another block.
+                        if (BinarySearch(blocks, currBlock.Address, out int nBlkIndex))
+                        {
+                            Block nBlock = blocks[nBlkIndex];
+
+                            if (nBlock.Address == currBlock.Address)
+                            {
+                                throw new InvalidOperationException("Found duplicate block address on the list.");
+                            }
+
+                            nBlock.Split(currBlock);
+                            blocks.Insert(nBlkIndex + 1, currBlock);
+
+                            continue;
+                        }
+
+                        // If we have a block after the current one, set the limit address.
+                        ulong limitAddress = ulong.MaxValue;
+
+                        if (nBlkIndex != blocks.Count)
+                        {
+                            Block nBlock = blocks[nBlkIndex];
+
+                            int nextIndex = nBlkIndex + 1;
+
+                            if (nBlock.Address < currBlock.Address && nextIndex < blocks.Count)
+                            {
+                                limitAddress = blocks[nextIndex].Address;
+                            }
+                            else if (nBlock.Address > currBlock.Address)
+                            {
+                                limitAddress = blocks[nBlkIndex].Address;
+                            }
+                        }
+
+                        FillBlock(config, currBlock, limitAddress, startAddress);
+
+                        if (currBlock.OpCodes.Count != 0)
+                        {
+                            // We should have blocks for all possible branch targets,
+                            // including those from PBK/PCNT/SSY instructions.
+                            foreach (PushOpInfo pushOp in currBlock.PushOpCodes)
+                            {
+                                GetBlock(pushOp.Op.GetAbsoluteAddress());
+                            }
+
+                            // Set child blocks. "Branch" is the block the branch instruction
+                            // points to (when taken), "Next" is the block at the next address,
+                            // executed when the branch is not taken. For Unconditional Branches
+                            // or end of program, Next is null.
+                            InstOp lastOp = currBlock.GetLastOp();
+
+                            if (lastOp.Name == InstName.Cal)
+                            {
+                                EnqueueFunction(lastOp.GetAbsoluteAddress()).AddCaller(currentFunction);
+                            }
+                            else if (lastOp.Name == InstName.Bra)
+                            {
+                                Block succBlock = GetBlock(lastOp.GetAbsoluteAddress());
+                                currBlock.Successors.Add(succBlock);
+                                succBlock.Predecessors.Add(currBlock);
+                            }
+
+                            if (!IsUnconditionalBranch(ref lastOp))
+                            {
+                                Block succBlock = GetBlock(currBlock.EndAddress);
+                                currBlock.Successors.Insert(0, succBlock);
+                                succBlock.Predecessors.Add(currBlock);
+                            }
+                        }
+
+                        // Insert the new block on the list (sorted by address).
+                        if (blocks.Count != 0)
+                        {
+                            Block nBlock = blocks[nBlkIndex];
+
+                            blocks.Insert(nBlkIndex + (nBlock.Address < currBlock.Address ? 1 : 0), currBlock);
+                        }
+                        else
+                        {
+                            blocks.Add(currBlock);
+                        }
+                    }
+
+                    // Propagate SSY/PBK addresses into their uses (SYNC/BRK).
+                    foreach (Block block in blocks.Where(x => x.PushOpCodes.Count != 0))
+                    {
+                        for (int pushOpIndex = 0; pushOpIndex < block.PushOpCodes.Count; pushOpIndex++)
+                        {
+                            PropagatePushOp(visited, block, pushOpIndex);
+                        }
+                    }
+
+                    // Try to find targets for BRX (indirect branch) instructions.
+                    hasNewTarget = FindBrxTargets(config, blocks, GetBlock);
+
+                    // If we discovered new branch targets from the BRX instruction,
+                    // we need another round of decoding to decode the new blocks.
+                    // Additionally, we may have more SSY/PBK targets to propagate,
+                    // and new BRX instructions.
+                }
+                while (hasNewTarget);
+
+                currentFunction.SetBlocks(blocks.ToArray());
+            }
+
+            return new DecodedProgram(mainFunction, functionsVisited);
+        }
+
+        private static bool BinarySearch(List<Block> blocks, ulong address, out int index)
+        {
+            index = 0;
+
+            int left  = 0;
+            int right = blocks.Count - 1;
+
+            while (left <= right)
+            {
+                int size = right - left;
+
+                int middle = left + (size >> 1);
+
+                Block block = blocks[middle];
+
+                index = middle;
+
+                if (address >= block.Address && address < block.EndAddress)
+                {
+                    return true;
+                }
+
+                if (address < block.Address)
+                {
+                    right = middle - 1;
+                }
+                else
+                {
+                    left = middle + 1;
+                }
+            }
+
+            return false;
+        }
+
+        private static void FillBlock(ShaderConfig config, Block block, ulong limitAddress, ulong startAddress)
+        {
+            IGpuAccessor gpuAccessor = config.GpuAccessor;
+
+            ulong address = block.Address;
+            int bufferOffset = 0;
+            ReadOnlySpan<ulong> buffer = ReadOnlySpan<ulong>.Empty;
+
+            InstOp op = default;
+
+            do
+            {
+                if (address + 7 >= limitAddress)
+                {
+                    break;
+                }
+
+                // Ignore scheduling instructions, which are written every 32 bytes.
+                if ((address & 0x1f) == 0)
+                {
+                    address += 8;
+                    bufferOffset++;
+                    continue;
+                }
+
+                if (bufferOffset >= buffer.Length)
+                {
+                    buffer = gpuAccessor.GetCode(startAddress + address, 8);
+                    bufferOffset = 0;
+                }
+
+                ulong opCode = buffer[bufferOffset++];
+
+                op = InstTable.GetOp(address, opCode);
+
+                if (op.Props.HasFlag(InstProps.TexB))
+                {
+                    config.SetUsedFeature(FeatureFlags.Bindless);
+                }
+
+                if (op.Name == InstName.Ald || op.Name == InstName.Ast || op.Name == InstName.Ipa)
+                {
+                    SetUserAttributeUses(config, op.Name, opCode);
+                }
+                else if (op.Name == InstName.Pbk || op.Name == InstName.Pcnt || op.Name == InstName.Ssy)
+                {
+                    block.AddPushOp(op);
+                }
+
+                block.OpCodes.Add(op);
+
+                address += 8;
+            }
+            while (!op.Props.HasFlag(InstProps.Bra));
+
+            block.EndAddress = address;
+        }
+
+        private static void SetUserAttributeUses(ShaderConfig config, InstName name, ulong opCode)
+        {
+            int offset;
+            int count = 1;
+            bool isStore = false;
+            bool indexed = false;
+            bool perPatch = false;
+
+            if (name == InstName.Ast)
+            {
+                InstAst opAst = new InstAst(opCode);
+                count = (int)opAst.AlSize + 1;
+                offset = opAst.Imm11;
+                indexed = opAst.Phys;
+                perPatch = opAst.P;
+                isStore = true;
+            }
+            else if (name == InstName.Ald)
+            {
+                InstAld opAld = new InstAld(opCode);
+                count = (int)opAld.AlSize + 1;
+                offset = opAld.Imm11;
+                indexed = opAld.Phys;
+                perPatch = opAld.P;
+                isStore = opAld.O;
+            }
+            else /* if (name == InstName.Ipa) */
+            {
+                InstIpa opIpa = new InstIpa(opCode);
+                offset = opIpa.Imm10;
+                indexed = opIpa.Idx;
+            }
+
+            if (indexed)
+            {
+                if (isStore)
+                {
+                    config.SetAllOutputUserAttributes();
+                    config.SetUsedFeature(FeatureFlags.OaIndexing);
+                }
+                else
+                {
+                    config.SetAllInputUserAttributes();
+                    config.SetUsedFeature(FeatureFlags.IaIndexing);
+                }
+            }
+            else
+            {
+                for (int elemIndex = 0; elemIndex < count; elemIndex++)
+                {
+                    int attr = offset + elemIndex * 4;
+
+                    if (perPatch)
+                    {
+                        if (attr >= AttributeConsts.UserAttributePerPatchBase && attr < AttributeConsts.UserAttributePerPatchEnd)
+                        {
+                            int userAttr = attr - AttributeConsts.UserAttributePerPatchBase;
+                            int index = userAttr / 16;
+
+                            if (isStore)
+                            {
+                                config.SetOutputUserAttributePerPatch(index);
+                            }
+                            else
+                            {
+                                config.SetInputUserAttributePerPatch(index);
+                            }
+                        }
+                    }
+                    else if (attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd)
+                    {
+                        int userAttr = attr - AttributeConsts.UserAttributeBase;
+                        int index = userAttr / 16;
+
+                        if (isStore)
+                        {
+                            config.SetOutputUserAttribute(index);
+                        }
+                        else
+                        {
+                            config.SetInputUserAttribute(index, (userAttr >> 2) & 3);
+                        }
+                    }
+
+                    if (!isStore &&
+                        (attr == AttributeConsts.FogCoord ||
+                        (attr >= AttributeConsts.FrontColorDiffuseR && attr < AttributeConsts.ClipDistance0) ||
+                        (attr >= AttributeConsts.TexCoordBase && attr < AttributeConsts.TexCoordEnd)))
+                    {
+                        config.SetUsedFeature(FeatureFlags.FixedFuncAttr);
+                    }
+                }
+            }
+        }
+
+        public static bool IsUnconditionalBranch(ref InstOp op)
+        {
+            return IsUnconditional(ref op) && op.Props.HasFlag(InstProps.Bra);
+        }
+
+        private static bool IsUnconditional(ref InstOp op)
+        {
+            InstConditional condOp = new InstConditional(op.RawOpCode);
+
+            if ((op.Name == InstName.Bra || op.Name == InstName.Exit) && condOp.Ccc != Ccc.T)
+            {
+                return false;
+            }
+
+            return condOp.Pred == RegisterConsts.PredicateTrueIndex && !condOp.PredInv;
+        }
+
+        private static bool FindBrxTargets(ShaderConfig config, IEnumerable<Block> blocks, Func<ulong, Block> getBlock)
+        {
+            bool hasNewTarget = false;
+
+            foreach (Block block in blocks)
+            {
+                InstOp lastOp = block.GetLastOp();
+                bool hasNext = block.HasNext();
+
+                if (lastOp.Name == InstName.Brx && block.Successors.Count == (hasNext ? 1 : 0))
+                {
+                    HashSet<ulong> visited = new HashSet<ulong>();
+
+                    InstBrx opBrx = new InstBrx(lastOp.RawOpCode);
+                    ulong baseOffset = lastOp.GetAbsoluteAddress();
+
+                    // An indirect branch could go anywhere,
+                    // try to get the possible target offsets from the constant buffer.
+                    (int cbBaseOffset, int cbOffsetsCount) = FindBrxTargetRange(block, opBrx.SrcA);
+
+                    if (cbOffsetsCount != 0)
+                    {
+                        hasNewTarget = true;
+                    }
+
+                    for (int i = 0; i < cbOffsetsCount; i++)
+                    {
+                        uint targetOffset = config.ConstantBuffer1Read(cbBaseOffset + i * 4);
+                        ulong targetAddress = baseOffset + targetOffset;
+
+                        if (visited.Add(targetAddress))
+                        {
+                            Block target = getBlock(targetAddress);
+                            target.Predecessors.Add(block);
+                            block.Successors.Add(target);
+                        }
+                    }
+                }
+            }
+
+            return hasNewTarget;
+        }
+
+        private static (int, int) FindBrxTargetRange(Block block, int brxReg)
+        {
+            // Try to match the following pattern:
+            //
+            // IMNMX.U32 Rx, Rx, UpperBound, PT
+            // SHL Rx, Rx, 0x2
+            // LDC Rx, c[0x1][Rx+BaseOffset]
+            //
+            // Here, Rx is an arbitrary register, "UpperBound" and "BaseOffset" are constants.
+            // The above pattern is assumed to be generated by the compiler before BRX,
+            // as the instruction is usually used to implement jump tables for switch statement optimizations.
+            // On a successful match, "BaseOffset" is the offset in bytes where the jump offsets are
+            // located on the constant buffer, and "UpperBound" is the total number of offsets for the BRX, minus 1.
+
+            HashSet<Block> visited = new HashSet<Block>();
+
+            var ldcLocation = FindFirstRegWrite(visited, new BlockLocation(block, block.OpCodes.Count - 1), brxReg);
+            if (ldcLocation.Block == null || ldcLocation.Block.OpCodes[ldcLocation.Index].Name != InstName.Ldc)
+            {
+                return (0, 0);
+            }
+
+            GetOp<InstLdc>(ldcLocation, out var opLdc);
+
+            if (opLdc.CbufSlot != 1 || opLdc.AddressMode != 0)
+            {
+                return (0, 0);
+            }
+
+            var shlLocation = FindFirstRegWrite(visited, ldcLocation, opLdc.SrcA);
+            if (shlLocation.Block == null || !shlLocation.IsImmInst(InstName.Shl))
+            {
+                return (0, 0);
+            }
+
+            GetOp<InstShlI>(shlLocation, out var opShl);
+
+            if (opShl.Imm20 != 2)
+            {
+                return (0, 0);
+            }
+
+            var imnmxLocation = FindFirstRegWrite(visited, shlLocation, opShl.SrcA);
+            if (imnmxLocation.Block == null || !imnmxLocation.IsImmInst(InstName.Imnmx))
+            {
+                return (0, 0);
+            }
+
+            GetOp<InstImnmxI>(imnmxLocation, out var opImnmx);
+
+            if (opImnmx.Signed || opImnmx.SrcPred != RegisterConsts.PredicateTrueIndex || opImnmx.SrcPredInv)
+            {
+                return (0, 0);
+            }
+
+            return (opLdc.CbufOffset, opImnmx.Imm20 + 1);
+        }
+
+        private static void GetOp<T>(BlockLocation location, out T op) where T : unmanaged
+        {
+            ulong rawOp = location.Block.OpCodes[location.Index].RawOpCode;
+            op = Unsafe.As<ulong, T>(ref rawOp);
+        }
+
+        private readonly struct BlockLocation
+        {
+            public Block Block { get; }
+            public int Index { get; }
+
+            public BlockLocation(Block block, int index)
+            {
+                Block = block;
+                Index = index;
+            }
+
+            public bool IsImmInst(InstName name)
+            {
+                InstOp op = Block.OpCodes[Index];
+                return op.Name == name && op.Props.HasFlag(InstProps.Ib);
+            }
+        }
+
+        private static BlockLocation FindFirstRegWrite(HashSet<Block> visited, BlockLocation location, int regIndex)
+        {
+            Queue<BlockLocation> toVisit = new Queue<BlockLocation>();
+            toVisit.Enqueue(location);
+            visited.Add(location.Block);
+
+            while (toVisit.TryDequeue(out var currentLocation))
+            {
+                Block block = currentLocation.Block;
+                for (int i = currentLocation.Index - 1; i >= 0; i--)
+                {
+                    if (WritesToRegister(block.OpCodes[i], regIndex))
+                    {
+                        return new BlockLocation(block, i);
+                    }
+                }
+
+                foreach (Block predecessor in block.Predecessors)
+                {
+                    if (visited.Add(predecessor))
+                    {
+                        toVisit.Enqueue(new BlockLocation(predecessor, predecessor.OpCodes.Count));
+                    }
+                }
+            }
+
+            return new BlockLocation(null, 0);
+        }
+
+        private static bool WritesToRegister(InstOp op, int regIndex)
+        {
+            // Predicate instruction only ever writes to predicate, so we shouldn't check those.
+            if ((op.Props & (InstProps.Rd | InstProps.Rd2)) == 0)
+            {
+                return false;
+            }
+
+            if (op.Props.HasFlag(InstProps.Rd2) && (byte)(op.RawOpCode >> 28) == regIndex)
+            {
+                return true;
+            }
+
+            return (byte)op.RawOpCode == regIndex;
+        }
+
+        private enum MergeType
+        {
+            Brk,
+            Cont,
+            Sync
+        }
+
+        private struct PathBlockState
+        {
+            public Block Block { get; }
+
+            private enum RestoreType
+            {
+                None,
+                PopPushOp,
+                PushBranchOp
+            }
+
+            private RestoreType _restoreType;
+
+            private ulong _restoreValue;
+            private MergeType _restoreMergeType;
+
+            public bool ReturningFromVisit => _restoreType != RestoreType.None;
+
+            public PathBlockState(Block block)
+            {
+                Block             = block;
+                _restoreType      = RestoreType.None;
+                _restoreValue     = 0;
+                _restoreMergeType = default;
+            }
+
+            public PathBlockState(int oldStackSize)
+            {
+                Block             = null;
+                _restoreType      = RestoreType.PopPushOp;
+                _restoreValue     = (ulong)oldStackSize;
+                _restoreMergeType = default;
+            }
+
+            public PathBlockState(ulong syncAddress, MergeType mergeType)
+            {
+                Block             = null;
+                _restoreType      = RestoreType.PushBranchOp;
+                _restoreValue     = syncAddress;
+                _restoreMergeType = mergeType;
+            }
+
+            public void RestoreStackState(Stack<(ulong, MergeType)> branchStack)
+            {
+                if (_restoreType == RestoreType.PushBranchOp)
+                {
+                    branchStack.Push((_restoreValue, _restoreMergeType));
+                }
+                else if (_restoreType == RestoreType.PopPushOp)
+                {
+                    while (branchStack.Count > (uint)_restoreValue)
+                    {
+                        branchStack.Pop();
+                    }
+                }
+            }
+        }
+
+        private static void PropagatePushOp(Dictionary<ulong, Block> blocks, Block currBlock, int pushOpIndex)
+        {
+            PushOpInfo pushOpInfo = currBlock.PushOpCodes[pushOpIndex];
+            InstOp pushOp = pushOpInfo.Op;
+
+            Block target = blocks[pushOp.GetAbsoluteAddress()];
+
+            Stack<PathBlockState> workQueue = new Stack<PathBlockState>();
+            HashSet<Block> visited = new HashSet<Block>();
+            Stack<(ulong, MergeType)> branchStack = new Stack<(ulong, MergeType)>();
+
+            void Push(PathBlockState pbs)
+            {
+                // When block is null, this means we are pushing a restore operation.
+                // Restore operations are used to undo the work done inside a block
+                // when we return from it, for example it pops addresses pushed by
+                // SSY/PBK instructions inside the block, and pushes addresses poped
+                // by SYNC/BRK.
+                // For blocks, if it's already visited, we just ignore to avoid going
+                // around in circles and getting stuck here.
+                if (pbs.Block == null || !visited.Contains(pbs.Block))
+                {
+                    workQueue.Push(pbs);
+                }
+            }
+
+            Push(new PathBlockState(currBlock));
+
+            while (workQueue.TryPop(out PathBlockState pbs))
+            {
+                if (pbs.ReturningFromVisit)
+                {
+                    pbs.RestoreStackState(branchStack);
+
+                    continue;
+                }
+
+                Block current = pbs.Block;
+
+                // If the block was already processed, we just ignore it, otherwise
+                // we would push the same child blocks of an already processed block,
+                // and go around in circles until memory is exhausted.
+                if (!visited.Add(current))
+                {
+                    continue;
+                }
+
+                int pushOpsCount = current.PushOpCodes.Count;
+                if (pushOpsCount != 0)
+                {
+                    Push(new PathBlockState(branchStack.Count));
+
+                    for (int index = pushOpIndex; index < pushOpsCount; index++)
+                    {
+                        InstOp currentPushOp = current.PushOpCodes[index].Op;
+                        MergeType pushMergeType = GetMergeTypeFromPush(currentPushOp.Name);
+                        branchStack.Push((currentPushOp.GetAbsoluteAddress(), pushMergeType));
+                    }
+                }
+
+                pushOpIndex = 0;
+
+                bool hasNext = current.HasNext();
+                if (hasNext)
+                {
+                    Push(new PathBlockState(current.Successors[0]));
+                }
+
+                InstOp lastOp = current.GetLastOp();
+                if (IsPopBranch(lastOp.Name))
+                {
+                    MergeType popMergeType = GetMergeTypeFromPop(lastOp.Name);
+
+                    bool found = true;
+                    ulong targetAddress = 0UL;
+                    MergeType mergeType;
+
+                    do
+                    {
+                        if (branchStack.Count == 0)
+                        {
+                            found = false;
+                            break;
+                        }
+
+                        (targetAddress, mergeType) = branchStack.Pop();
+
+                        // Push the target address (this will be used to push the address
+                        // back into the PBK/PCNT/SSY stack when we return from that block),
+                        Push(new PathBlockState(targetAddress, mergeType));
+                    }
+                    while (mergeType != popMergeType);
+
+                    // Make sure we found the correct address,
+                    // the push and pop instruction types must match, so:
+                    // - BRK can only consume addresses pushed by PBK.
+                    // - CONT can only consume addresses pushed by PCNT.
+                    // - SYNC can only consume addresses pushed by SSY.
+                    if (found)
+                    {
+                        if (branchStack.Count == 0)
+                        {
+                            // If the entire stack was consumed, then the current pop instruction
+                            // just consumed the address from our push instruction.
+                            if (current.SyncTargets.TryAdd(pushOp.Address, new SyncTarget(pushOpInfo, current.SyncTargets.Count)))
+                            {
+                                pushOpInfo.Consumers.Add(current, Local());
+                                target.Predecessors.Add(current);
+                                current.Successors.Add(target);
+                            }
+                        }
+                        else
+                        {
+                            // Push the block itself into the work queue for processing.
+                            Push(new PathBlockState(blocks[targetAddress]));
+                        }
+                    }
+                }
+                else
+                {
+                    // By adding them in descending order (sorted by address), we process the blocks
+                    // in order (of ascending address), since we work with a LIFO.
+                    foreach (Block possibleTarget in current.Successors.OrderByDescending(x => x.Address))
+                    {
+                        if (!hasNext || possibleTarget != current.Successors[0])
+                        {
+                            Push(new PathBlockState(possibleTarget));
+                        }
+                    }
+                }
+            }
+        }
+
+        public static bool IsPopBranch(InstName name)
+        {
+            return name == InstName.Brk || name == InstName.Cont || name == InstName.Sync;
+        }
+
+        private static MergeType GetMergeTypeFromPush(InstName name)
+        {
+            return name switch
+            {
+                InstName.Pbk => MergeType.Brk,
+                InstName.Pcnt => MergeType.Cont,
+                _ => MergeType.Sync
+            };
+        }
+
+        private static MergeType GetMergeTypeFromPop(InstName name)
+        {
+            return name switch
+            {
+                InstName.Brk => MergeType.Brk,
+                InstName.Cont => MergeType.Cont,
+                _ => MergeType.Sync
+            };
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/FunctionType.cs b/src/Ryujinx.Graphics.Shader/Decoders/FunctionType.cs
new file mode 100644
index 00000000..6ea6a82a
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/FunctionType.cs
@@ -0,0 +1,10 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    enum FunctionType : byte
+    {
+        User,
+        Unused,
+        BuiltInFSIBegin,
+        BuiltInFSIEnd
+    }
+}
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs b/src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs
new file mode 100644
index 00000000..0c22ddc0
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs
@@ -0,0 +1,5383 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    enum AlSize
+    {
+        _32 = 0,
+        _64 = 1,
+        _96 = 2,
+        _128 = 3,
+    }
+
+    enum AtomSize
+    {
+        U32 = 0,
+        S32 = 1,
+        U64 = 2,
+        F32FtzRn = 3,
+        F16x2FtzRn = 4,
+        S64 = 5,
+    }
+
+    enum AtomOp
+    {
+        Add = 0,
+        Min = 1,
+        Max = 2,
+        Inc = 3,
+        Dec = 4,
+        And = 5,
+        Or = 6,
+        Xor = 7,
+        Exch = 8,
+        Safeadd = 10,
+    }
+
+    enum AtomsSize
+    {
+        U32 = 0,
+        S32 = 1,
+        U64 = 2,
+        S64 = 3,
+    }
+
+    enum BarMode
+    {
+        Bar = 0,
+        Result = 1,
+        Warp = 2,
+    }
+
+    enum BarOp
+    {
+        Sync = 0,
+        Arv = 1,
+        Red = 2,
+        Scan = 3,
+        SyncAll = 4,
+    }
+
+    enum BarRedOp
+    {
+        Popc = 0,
+        And = 1,
+        Or = 2,
+    }
+
+    enum Bpt
+    {
+        DrainIllegal = 0,
+        Cal = 1,
+        Pause = 2,
+        Trap = 3,
+        Int = 4,
+        Drain = 5,
+    }
+
+    enum Ccc
+    {
+        F = 0,
+        Lt = 1,
+        Eq = 2,
+        Le = 3,
+        Gt = 4,
+        Ne = 5,
+        Ge = 6,
+        Num = 7,
+        Nan = 8,
+        Ltu = 9,
+        Equ = 10,
+        Leu = 11,
+        Gtu = 12,
+        Neu = 13,
+        Geu = 14,
+        T = 15,
+        Off = 16,
+        Lo = 17,
+        Sff = 18,
+        Ls = 19,
+        Hi = 20,
+        Sft = 21,
+        Hs = 22,
+        Oft = 23,
+        CsmTa = 24,
+        CsmTr = 25,
+        CsmMx = 26,
+        FcsmTa = 27,
+        FcsmTr = 28,
+        FcsmMx = 29,
+        Rle = 30,
+        Rgt = 31,
+    }
+
+    enum CacheType
+    {
+        U = 1,
+        C = 2,
+        I = 3,
+        Crs = 4,
+    }
+
+    enum CctlOp
+    {
+        Pf1 = 1,
+        Pf1_5 = 2,
+        Pf2 = 3,
+        Wb = 4,
+        Iv = 5,
+        Ivall = 6,
+        Rs = 7,
+        Rslb = 9,
+    }
+
+    enum CctltOp
+    {
+        Ivth = 1,
+    }
+
+    enum BoolOp
+    {
+        And = 0,
+        Or = 1,
+        Xor = 2,
+    }
+
+    enum SReg
+    {
+        LaneId = 0,
+        Clock = 1,
+        VirtCfg = 2,
+        VirtId = 3,
+        Pm0 = 4,
+        Pm1 = 5,
+        Pm2 = 6,
+        Pm3 = 7,
+        Pm4 = 8,
+        Pm5 = 9,
+        Pm6 = 10,
+        Pm7 = 11,
+        OrderingTicket = 15,
+        PrimType = 16,
+        InvocationId = 17,
+        YDirection = 18,
+        ThreadKill = 19,
+        ShaderType = 20,
+        DirectCbeWriteAddressLow = 21,
+        DirectCbeWriteAddressHigh = 22,
+        DirectCbeWriteEnabled = 23,
+        MachineId0 = 24,
+        MachineId1 = 25,
+        MachineId2 = 26,
+        MachineId3 = 27,
+        Affinity = 28,
+        InvocationInfo = 29,
+        WScaleFactorXY = 30,
+        WScaleFactorZ = 31,
+        TId = 32,
+        TIdX = 33,
+        TIdY = 34,
+        TIdZ = 35,
+        CtaParam = 36,
+        CtaIdX = 37,
+        CtaIdY = 38,
+        CtaIdZ = 39,
+        Ntid = 40,
+        CirQueueIncrMinusOne = 41,
+        Nlatc = 42,
+        Swinlo = 48,
+        Swinsz = 49,
+        Smemsz = 50,
+        Smembanks = 51,
+        LWinLo = 52,
+        LWinSz = 53,
+        LMemLoSz = 54,
+        LMemHiOff = 55,
+        EqMask = 56,
+        LtMask = 57,
+        LeMask = 58,
+        GtMask = 59,
+        GeMask = 60,
+        RegAlloc = 61,
+        CtxAddr = 62,
+        GlobalErrorStatus = 64,
+        WarpErrorStatus = 66,
+        WarpErrorStatusClear = 67,
+        PmHi0 = 72,
+        PmHi1 = 73,
+        PmHi2 = 74,
+        PmHi3 = 75,
+        PmHi4 = 76,
+        PmHi5 = 77,
+        PmHi6 = 78,
+        PmHi7 = 79,
+        ClockLo = 80,
+        ClockHi = 81,
+        GlobalTimerLo = 82,
+        GlobalTimerHi = 83,
+        HwTaskId = 96,
+        CircularQueueEntryIndex = 97,
+        CircularQueueEntryAddressLow = 98,
+        CircularQueueEntryAddressHigh = 99,
+    }
+
+    enum RoundMode
+    {
+        Rn = 0,
+        Rm = 1,
+        Rp = 2,
+        Rz = 3,
+    }
+
+    enum FComp
+    {
+        F = 0,
+        Lt = 1,
+        Eq = 2,
+        Le = 3,
+        Gt = 4,
+        Ne = 5,
+        Ge = 6,
+        Num = 7,
+        Nan = 8,
+        Ltu = 9,
+        Equ = 10,
+        Leu = 11,
+        Gtu = 12,
+        Neu = 13,
+        Geu = 14,
+        T = 15,
+    }
+
+    enum IntegerRound
+    {
+        Pass = 1,
+        Round = 4,
+        Floor = 5,
+        Ceil = 6,
+        Trunc = 7,
+    }
+
+    enum IDstFmt
+    {
+        U16 = 1,
+        U32 = 2,
+        U64 = 3,
+        S16 = 5,
+        S32 = 6,
+        S64 = 7,
+    }
+
+    enum ISrcFmt
+    {
+        U8 = 0,
+        U16 = 1,
+        U32 = 2,
+        U64 = 3,
+        S8 = 4,
+        S16 = 5,
+        S32 = 6,
+        S64 = 7,
+    }
+
+    enum ISrcDstFmt
+    {
+        U8 = 0,
+        U16 = 1,
+        U32 = 2,
+        S8 = 4,
+        S16 = 5,
+        S32 = 6,
+    }
+
+    enum RoundMode2
+    {
+        Round = 0,
+        Floor = 1,
+        Ceil = 2,
+        Trunc = 3,
+    }
+
+    enum ChkModeF
+    {
+        Divide = 0,
+    }
+
+    enum Fmz
+    {
+        Ftz = 1,
+        Fmz = 2,
+    }
+
+    enum MultiplyScale
+    {
+        NoScale = 0,
+        D2 = 1,
+        D4 = 2,
+        D8 = 3,
+        M8 = 4,
+        M4 = 5,
+        M2 = 6,
+    }
+
+    enum OFmt
+    {
+        F16 = 0,
+        F32 = 1,
+        MrgH0 = 2,
+        MrgH1 = 3,
+    }
+
+    enum HalfSwizzle
+    {
+        F16 = 0,
+        F32 = 1,
+        H0H0 = 2,
+        H1H1 = 3,
+    }
+
+    enum ByteSel
+    {
+        B0 = 0,
+        B1 = 1,
+        B2 = 2,
+        B3 = 3,
+    }
+
+    enum DstFmt
+    {
+        F16 = 1,
+        F32 = 2,
+        F64 = 3,
+    }
+
+    enum AvgMode
+    {
+        NoNeg = 0,
+        NegB = 1,
+        NegA = 2,
+        PlusOne = 3,
+    }
+
+    enum Lrs
+    {
+        None = 0,
+        RightShift = 1,
+        LeftShift = 2,
+    }
+
+    enum HalfSelect
+    {
+        B32 = 0,
+        H0 = 1,
+        H1 = 2,
+    }
+
+    enum IComp
+    {
+        F = 0,
+        Lt = 1,
+        Eq = 2,
+        Le = 3,
+        Gt = 4,
+        Ne = 5,
+        Ge = 6,
+        T = 7,
+    }
+
+    enum XMode
+    {
+        Xlo = 1,
+        Xmed = 2,
+        Xhi = 3,
+    }
+
+    enum IpaOp
+    {
+        Pass = 0,
+        Multiply = 1,
+        Constant = 2,
+        Sc = 3,
+    }
+
+    enum IBase
+    {
+        Patch = 1,
+        Prim = 2,
+        Attr = 3,
+    }
+
+    enum CacheOpLd
+    {
+        Ca = 0,
+        Cg = 1,
+        Ci = 2,
+        Cv = 3,
+    }
+
+    enum CacheOpSt
+    {
+        Wb = 0,
+        Cg = 1,
+        Ci = 2,
+        Wt = 3,
+    }
+
+    enum LsSize
+    {
+        U8 = 0,
+        S8 = 1,
+        U16 = 2,
+        S16 = 3,
+        B32 = 4,
+        B64 = 5,
+        B128 = 6,
+        UB128 = 7,
+    }
+
+    enum LsSize2
+    {
+        U8 = 0,
+        S8 = 1,
+        U16 = 2,
+        S16 = 3,
+        B32 = 4,
+        B64 = 5,
+        B128 = 6,
+    }
+
+    enum AddressMode
+    {
+        Il = 1,
+        Is = 2,
+        Isl = 3,
+    }
+
+    enum CacheOp2
+    {
+        Lu = 1,
+        Ci = 2,
+        Cv = 3,
+    }
+
+    enum PredicateOp
+    {
+        F = 0,
+        T = 1,
+        Z = 2,
+        Nz = 3,
+    }
+
+    enum LogicOp
+    {
+        And = 0,
+        Or = 1,
+        Xor = 2,
+        PassB = 3,
+    }
+
+    enum Membar
+    {
+        Cta = 0,
+        Gl = 1,
+        Sys = 2,
+        Vc = 3,
+    }
+
+    enum Ivall
+    {
+        Ivalld = 1,
+        Ivallt = 2,
+        Ivalltd = 3,
+    }
+
+    enum MufuOp
+    {
+        Cos = 0,
+        Sin = 1,
+        Ex2 = 2,
+        Lg2 = 3,
+        Rcp = 4,
+        Rsq = 5,
+        Rcp64h = 6,
+        Rsq64h = 7,
+        Sqrt = 8,
+    }
+
+    enum OutType
+    {
+        Emit = 1,
+        Cut = 2,
+        EmitThenCut = 3,
+    }
+
+    enum PixMode
+    {
+        Covmask = 1,
+        Covered = 2,
+        Offset = 3,
+        CentroidOffset = 4,
+        MyIndex = 5,
+    }
+
+    enum PMode
+    {
+        F4e = 1,
+        B4e = 2,
+        Rc8 = 3,
+        Ecl = 4,
+        Ecr = 5,
+        Rc16 = 6,
+    }
+
+    enum RedOp
+    {
+        Add = 0,
+        Min = 1,
+        Max = 2,
+        Inc = 3,
+        Dec = 4,
+        And = 5,
+        Or = 6,
+        Xor = 7,
+    }
+
+    enum XModeShf
+    {
+        Hi = 1,
+        X = 2,
+        Xhi = 3,
+    }
+
+    enum MaxShift
+    {
+        U64 = 2,
+        S64 = 3,
+    }
+
+    enum ShflMode
+    {
+        Idx = 0,
+        Up = 1,
+        Down = 2,
+        Bfly = 3,
+    }
+
+    enum Clamp
+    {
+        Ign = 0,
+        Trap = 2,
+    }
+
+    enum SuatomSize
+    {
+        U32 = 0,
+        S32 = 1,
+        U64 = 2,
+        F32FtzRn = 3,
+        F16x2FtzRn = 4,
+        S64 = 5,
+        Sd32 = 6,
+        Sd64 = 7,
+    }
+
+    enum SuDim
+    {
+        _1d = 0,
+        _1dBuffer = 1,
+        _1dArray = 2,
+        _2d = 3,
+        _2dArray = 4,
+        _3d = 5,
+    }
+
+    enum SuatomOp
+    {
+        Add = 0,
+        Min = 1,
+        Max = 2,
+        Inc = 3,
+        Dec = 4,
+        And = 5,
+        Or = 6,
+        Xor = 7,
+        Exch = 8,
+    }
+
+    enum SuSize
+    {
+        U8 = 0,
+        S8 = 1,
+        U16 = 2,
+        S16 = 3,
+        B32 = 4,
+        B64 = 5,
+        B128 = 6,
+        UB128 = 7,
+    }
+
+    enum SuRgba
+    {
+        R = 1,
+        G = 2,
+        Rg = 3,
+        B = 4,
+        Rb = 5,
+        Gb = 6,
+        Rgb = 7,
+        A = 8,
+        Ra = 9,
+        Ga = 10,
+        Rga = 11,
+        Ba = 12,
+        Rba = 13,
+        Gba = 14,
+        Rgba = 15,
+    }
+
+    enum Lod
+    {
+        Lz = 1,
+        Lb = 2,
+        Ll = 3,
+        Lba = 6,
+        Lla = 7,
+    }
+
+    enum TexDim
+    {
+        _1d = 0,
+        Array1d = 1,
+        _2d = 2,
+        Array2d = 3,
+        _3d = 4,
+        Array3d = 5,
+        Cube = 6,
+        ArrayCube = 7,
+    }
+
+    enum TexsTarget
+    {
+        Texture1DLodZero = 0,
+        Texture2D = 1,
+        Texture2DLodZero = 2,
+        Texture2DLodLevel = 3,
+        Texture2DDepthCompare = 4,
+        Texture2DLodLevelDepthCompare = 5,
+        Texture2DLodZeroDepthCompare = 6,
+        Texture2DArray = 7,
+        Texture2DArrayLodZero = 8,
+        Texture2DArrayLodZeroDepthCompare = 9,
+        Texture3D = 10,
+        Texture3DLodZero = 11,
+        TextureCube = 12,
+        TextureCubeLodLevel = 13,
+    }
+
+    enum TldsTarget
+    {
+        Texture1DLodZero = 0x0,
+        Texture1DLodLevel = 0x1,
+        Texture2DLodZero = 0x2,
+        Texture2DLodZeroOffset = 0x4,
+        Texture2DLodLevel = 0x5,
+        Texture2DLodZeroMultisample = 0x6,
+        Texture3DLodZero = 0x7,
+        Texture2DArrayLodZero = 0x8,
+        Texture2DLodLevelOffset = 0xc
+    }
+
+    enum TexComp
+    {
+        R = 0,
+        G = 1,
+        B = 2,
+        A = 3,
+    }
+
+    enum TexOffset
+    {
+        None = 0,
+        Aoffi = 1,
+        Ptp = 2,
+    }
+
+    enum TexQuery
+    {
+        TexHeaderDimension = 1,
+        TexHeaderTextureType = 2,
+        TexHeaderSamplerPos = 5,
+        TexSamplerFilter = 16,
+        TexSamplerLod = 18,
+        TexSamplerWrap = 20,
+        TexSamplerBorderColor = 22,
+    }
+
+    enum VectorSelect
+    {
+        U8B0 = 0,
+        U8B1 = 1,
+        U8B2 = 2,
+        U8B3 = 3,
+        U16H0 = 4,
+        U16H1 = 5,
+        U32 = 6,
+        S8B0 = 8,
+        S8B1 = 9,
+        S8B2 = 10,
+        S8B3 = 11,
+        S16H0 = 12,
+        S16H1 = 13,
+        S32 = 14,
+    }
+
+    enum VideoOp
+    {
+        Mrg16h = 0,
+        Mrg16l = 1,
+        Mrg8b0 = 2,
+        Mrg8b2 = 3,
+        Acc = 4,
+        Min = 5,
+        Max = 6,
+    }
+
+    enum VideoRed
+    {
+        Acc = 1,
+    }
+
+    enum LaneMask4
+    {
+        Z = 1,
+        W = 2,
+        Zw = 3,
+        X = 4,
+        Xz = 5,
+        Xw = 6,
+        Xzw = 7,
+        Y = 8,
+        Yz = 9,
+        Yw = 10,
+        Yzw = 11,
+        Xy = 12,
+        Xyz = 13,
+        Xyw = 14,
+        Xyzw = 15,
+    }
+
+    enum ASelect4
+    {
+        _0000 = 0,
+        _1111 = 1,
+        _2222 = 2,
+        _3333 = 3,
+        _3210 = 4,
+        _5432 = 6,
+        _6543 = 7,
+        _3201 = 8,
+        _3012 = 9,
+        _0213 = 10,
+        _3120 = 11,
+        _1230 = 12,
+        _2310 = 13,
+    }
+
+    enum BSelect4
+    {
+        _4444 = 0,
+        _5555 = 1,
+        _6666 = 2,
+        _7777 = 3,
+        _7654 = 4,
+        _5432 = 6,
+        _4321 = 7,
+        _4567 = 8,
+        _6745 = 9,
+        _5476 = 10,
+    }
+
+    enum VideoScale
+    {
+        Shr7 = 1,
+        Shr15 = 2,
+    }
+
+    enum VoteMode
+    {
+        All = 0,
+        Any = 1,
+        Eq = 2,
+    }
+
+    enum XmadCop
+    {
+        Cfull = 0,
+        Clo = 1,
+        Chi = 2,
+        Csfu = 3,
+        Cbcc = 4,
+    }
+
+    enum XmadCop2
+    {
+        Cfull = 0,
+        Clo = 1,
+        Chi = 2,
+        Csfu = 3,
+    }
+
+    enum ImadspASelect
+    {
+        U32 = 0,
+        S32 = 1,
+        U24 = 2,
+        S24 = 3,
+        U16h0 = 4,
+        S16h0 = 5,
+        U16h1 = 6,
+        S16h1 = 7,
+    }
+
+    enum ImadspBSelect
+    {
+        U24 = 0,
+        S24 = 1,
+        U16h0 = 2,
+        S16h0 = 3,
+    }
+
+    struct InstConditional
+    {
+        private ulong _opcode;
+        public InstConditional(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstAl2p
+    {
+        private ulong _opcode;
+        public InstAl2p(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public AlSize AlSize => (AlSize)((_opcode >> 47) & 0x3);
+        public bool Aio => (_opcode & 0x100000000) != 0;
+        public int Imm11 => (int)((_opcode >> 20) & 0x7FF);
+        public int DestPred => (int)((_opcode >> 44) & 0x7);
+    }
+
+    struct InstAld
+    {
+        private ulong _opcode;
+        public InstAld(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm11 => (int)((_opcode >> 20) & 0x7FF);
+        public bool P => (_opcode & 0x80000000) != 0;
+        public bool O => (_opcode & 0x100000000) != 0;
+        public AlSize AlSize => (AlSize)((_opcode >> 47) & 0x3);
+        public bool Phys => !P && Imm11 == 0 && SrcA != RegisterConsts.RegisterZeroIndex;
+    }
+
+    struct InstAst
+    {
+        private ulong _opcode;
+        public InstAst(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 0) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm11 => (int)((_opcode >> 20) & 0x7FF);
+        public bool P => (_opcode & 0x80000000) != 0;
+        public AlSize AlSize => (AlSize)((_opcode >> 47) & 0x3);
+        public bool Phys => !P && Imm11 == 0 && SrcA != RegisterConsts.RegisterZeroIndex;
+    }
+
+    struct InstAtom
+    {
+        private ulong _opcode;
+        public InstAtom(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm20 => (int)((_opcode >> 28) & 0xFFFFF);
+        public AtomSize Size => (AtomSize)((_opcode >> 49) & 0x7);
+        public AtomOp Op => (AtomOp)((_opcode >> 52) & 0xF);
+        public bool E => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstAtomCas
+    {
+        private ulong _opcode;
+        public InstAtomCas(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int BcRz => (int)((_opcode >> 50) & 0x3);
+        public bool E => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstAtoms
+    {
+        private ulong _opcode;
+        public InstAtoms(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm22 => (int)((_opcode >> 30) & 0x3FFFFF);
+        public AtomsSize AtomsSize => (AtomsSize)((_opcode >> 28) & 0x3);
+        public AtomOp AtomOp => (AtomOp)((_opcode >> 52) & 0xF);
+    }
+
+    struct InstAtomsCas
+    {
+        private ulong _opcode;
+        public InstAtomsCas(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int AtomsBcRz => (int)((_opcode >> 28) & 0x3);
+    }
+
+    struct InstB2r
+    {
+        private ulong _opcode;
+        public InstB2r(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int DestPred => (int)((_opcode >> 45) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public BarMode Mode => (BarMode)((_opcode >> 32) & 0x3);
+    }
+
+    struct InstBar
+    {
+        private ulong _opcode;
+        public InstBar(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm12 => (int)((_opcode >> 20) & 0xFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public BarOp BarOp => (BarOp)((_opcode >> 32) & 0x7);
+        public BarRedOp BarRedOp => (BarRedOp)((_opcode >> 35) & 0x3);
+        public bool AFixBar => (_opcode & 0x100000000000) != 0;
+        public bool BFixBar => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstBfeR
+    {
+        private ulong _opcode;
+        public InstBfeR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstBfeI
+    {
+        private ulong _opcode;
+        public InstBfeI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstBfeC
+    {
+        private ulong _opcode;
+        public InstBfeC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstBfiR
+    {
+        private ulong _opcode;
+        public InstBfiR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstBfiI
+    {
+        private ulong _opcode;
+        public InstBfiI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstBfiC
+    {
+        private ulong _opcode;
+        public InstBfiC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstBfiRc
+    {
+        private ulong _opcode;
+        public InstBfiRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstBpt
+    {
+        private ulong _opcode;
+        public InstBpt(ulong opcode) => _opcode = opcode;
+        public int Imm20 => (int)((_opcode >> 20) & 0xFFFFF);
+        public Bpt Bpt => (Bpt)((_opcode >> 6) & 0x7);
+    }
+
+    struct InstBra
+    {
+        private ulong _opcode;
+        public InstBra(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+        public bool Lmt => (_opcode & 0x40) != 0;
+        public bool U => (_opcode & 0x80) != 0;
+    }
+
+    struct InstBrk
+    {
+        private ulong _opcode;
+        public InstBrk(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstBrx
+    {
+        private ulong _opcode;
+        public InstBrx(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+        public bool Lmt => (_opcode & 0x40) != 0;
+    }
+
+    struct InstCal
+    {
+        private ulong _opcode;
+        public InstCal(ulong opcode) => _opcode = opcode;
+        public bool Ca => (_opcode & 0x20) != 0;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Inc => (_opcode & 0x40) != 0;
+    }
+
+    struct InstCctl
+    {
+        private ulong _opcode;
+        public InstCctl(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm30 => (int)((_opcode >> 22) & 0x3FFFFFFF);
+        public bool E => (_opcode & 0x10000000000000) != 0;
+        public CacheType Cache => (CacheType)((_opcode >> 4) & 0x7);
+        public CctlOp CctlOp => (CctlOp)((_opcode >> 0) & 0xF);
+    }
+
+    struct InstCctll
+    {
+        private ulong _opcode;
+        public InstCctll(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm22 => (int)((_opcode >> 22) & 0x3FFFFF);
+        public int Cache => (int)((_opcode >> 4) & 0x3);
+        public CctlOp CctlOp => (CctlOp)((_opcode >> 0) & 0xF);
+    }
+
+    struct InstCctlt
+    {
+        private ulong _opcode;
+        public InstCctlt(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int TsIdx13 => (int)((_opcode >> 36) & 0x1FFF);
+        public CctltOp CctltOp => (CctltOp)((_opcode >> 0) & 0x3);
+    }
+
+    struct InstCctltR
+    {
+        private ulong _opcode;
+        public InstCctltR(ulong opcode) => _opcode = opcode;
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public CctltOp CctltOp => (CctltOp)((_opcode >> 0) & 0x3);
+    }
+
+    struct InstCont
+    {
+        private ulong _opcode;
+        public InstCont(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstCset
+    {
+        private ulong _opcode;
+        public InstCset(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 8) & 0x1F);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool BVal => (_opcode & 0x100000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+    }
+
+    struct InstCsetp
+    {
+        private ulong _opcode;
+        public InstCsetp(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 8) & 0x1F);
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+    }
+
+    struct InstCs2r
+    {
+        private ulong _opcode;
+        public InstCs2r(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public SReg SReg => (SReg)((_opcode >> 20) & 0xFF);
+    }
+
+    struct InstDaddR
+    {
+        private ulong _opcode;
+        public InstDaddR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstDaddI
+    {
+        private ulong _opcode;
+        public InstDaddI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstDaddC
+    {
+        private ulong _opcode;
+        public InstDaddC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstDepbar
+    {
+        private ulong _opcode;
+        public InstDepbar(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Le => (_opcode & 0x20000000) != 0;
+        public int Sbid => (int)((_opcode >> 26) & 0x7);
+        public int PendCnt => (int)((_opcode >> 20) & 0x3F);
+        public int Imm6 => (int)((_opcode >> 0) & 0x3F);
+    }
+
+    struct InstDfmaR
+    {
+        private ulong _opcode;
+        public InstDfmaR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 50) & 0x3);
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDfmaI
+    {
+        private ulong _opcode;
+        public InstDfmaI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 50) & 0x3);
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDfmaC
+    {
+        private ulong _opcode;
+        public InstDfmaC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 50) & 0x3);
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDfmaRc
+    {
+        private ulong _opcode;
+        public InstDfmaRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 50) & 0x3);
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDmnmxR
+    {
+        private ulong _opcode;
+        public InstDmnmxR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDmnmxI
+    {
+        private ulong _opcode;
+        public InstDmnmxI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDmnmxC
+    {
+        private ulong _opcode;
+        public InstDmnmxC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDmulR
+    {
+        private ulong _opcode;
+        public InstDmulR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDmulI
+    {
+        private ulong _opcode;
+        public InstDmulI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDmulC
+    {
+        private ulong _opcode;
+        public InstDmulC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstDsetR
+    {
+        private ulong _opcode;
+        public InstDsetR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDsetI
+    {
+        private ulong _opcode;
+        public InstDsetI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDsetC
+    {
+        private ulong _opcode;
+        public InstDsetC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstDsetpR
+    {
+        private ulong _opcode;
+        public InstDsetpR(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstDsetpI
+    {
+        private ulong _opcode;
+        public InstDsetpI(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstDsetpC
+    {
+        private ulong _opcode;
+        public InstDsetpC(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstExit
+    {
+        private ulong _opcode;
+        public InstExit(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+        public bool KeepRefCnt => (_opcode & 0x20) != 0;
+    }
+
+    struct InstF2fR
+    {
+        private ulong _opcode;
+        public InstF2fR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public IntegerRound RoundMode => (IntegerRound)((int)((_opcode >> 40) & 0x4) | (int)((_opcode >> 39) & 0x3));
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstF2fI
+    {
+        private ulong _opcode;
+        public InstF2fI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public IntegerRound RoundMode => (IntegerRound)((int)((_opcode >> 40) & 0x4) | (int)((_opcode >> 39) & 0x3));
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstF2fC
+    {
+        private ulong _opcode;
+        public InstF2fC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public IntegerRound RoundMode => (IntegerRound)((int)((_opcode >> 40) & 0x4) | (int)((_opcode >> 39) & 0x3));
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstF2iR
+    {
+        private ulong _opcode;
+        public InstF2iR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public IDstFmt IDstFmt => (IDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public RoundMode2 RoundMode => (RoundMode2)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstF2iI
+    {
+        private ulong _opcode;
+        public InstF2iI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public IDstFmt IDstFmt => (IDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public RoundMode2 RoundMode => (RoundMode2)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstF2iC
+    {
+        private ulong _opcode;
+        public InstF2iC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public IDstFmt IDstFmt => (IDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public DstFmt SrcFmt => (DstFmt)((_opcode >> 10) & 0x3);
+        public RoundMode2 RoundMode => (RoundMode2)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstFaddR
+    {
+        private ulong _opcode;
+        public InstFaddR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstFaddI
+    {
+        private ulong _opcode;
+        public InstFaddI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstFaddC
+    {
+        private ulong _opcode;
+        public InstFaddC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstFadd32i
+    {
+        private ulong _opcode;
+        public InstFadd32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool AbsB => (_opcode & 0x200000000000000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public bool Ftz => (_opcode & 0x80000000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+    }
+
+    struct InstFchkR
+    {
+        private ulong _opcode;
+        public InstFchkR(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ChkModeF ChkModeF => (ChkModeF)((_opcode >> 39) & 0x3F);
+    }
+
+    struct InstFchkI
+    {
+        private ulong _opcode;
+        public InstFchkI(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ChkModeF ChkModeF => (ChkModeF)((_opcode >> 39) & 0x3F);
+    }
+
+    struct InstFchkC
+    {
+        private ulong _opcode;
+        public InstFchkC(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ChkModeF ChkModeF => (ChkModeF)((_opcode >> 39) & 0x3F);
+    }
+
+    struct InstFcmpR
+    {
+        private ulong _opcode;
+        public InstFcmpR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFcmpI
+    {
+        private ulong _opcode;
+        public InstFcmpI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFcmpC
+    {
+        private ulong _opcode;
+        public InstFcmpC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFcmpRc
+    {
+        private ulong _opcode;
+        public InstFcmpRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFfmaR
+    {
+        private ulong _opcode;
+        public InstFfmaR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 51) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+    }
+
+    struct InstFfmaI
+    {
+        private ulong _opcode;
+        public InstFfmaI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 51) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+    }
+
+    struct InstFfmaC
+    {
+        private ulong _opcode;
+        public InstFfmaC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 51) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+    }
+
+    struct InstFfmaRc
+    {
+        private ulong _opcode;
+        public InstFfmaRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 51) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+    }
+
+    struct InstFfma32i
+    {
+        private ulong _opcode;
+        public InstFfma32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm32 => (int)(_opcode >> 20);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegC => (_opcode & 0x200000000000000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+    }
+
+    struct InstFloR
+    {
+        private ulong _opcode;
+        public InstFloR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstFloI
+    {
+        private ulong _opcode;
+        public InstFloI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstFloC
+    {
+        private ulong _opcode;
+        public InstFloC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public bool Sh => (_opcode & 0x20000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstFmnmxR
+    {
+        private ulong _opcode;
+        public InstFmnmxR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstFmnmxI
+    {
+        private ulong _opcode;
+        public InstFmnmxI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstFmnmxC
+    {
+        private ulong _opcode;
+        public InstFmnmxC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstFmulR
+    {
+        private ulong _opcode;
+        public InstFmulR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 44) & 0x3);
+        public MultiplyScale Scale => (MultiplyScale)((_opcode >> 41) & 0x7);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstFmulI
+    {
+        private ulong _opcode;
+        public InstFmulI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 44) & 0x3);
+        public MultiplyScale Scale => (MultiplyScale)((_opcode >> 41) & 0x7);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstFmulC
+    {
+        private ulong _opcode;
+        public InstFmulC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public Fmz Fmz => (Fmz)((_opcode >> 44) & 0x3);
+        public MultiplyScale Scale => (MultiplyScale)((_opcode >> 41) & 0x7);
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstFmul32i
+    {
+        private ulong _opcode;
+        public InstFmul32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 53) & 0x3);
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+    }
+
+    struct InstFsetR
+    {
+        private ulong _opcode;
+        public InstFsetR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x80000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+    }
+
+    struct InstFsetC
+    {
+        private ulong _opcode;
+        public InstFsetC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x80000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+    }
+
+    struct InstFsetI
+    {
+        private ulong _opcode;
+        public InstFsetI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x20000000000000) != 0;
+        public bool AbsA => (_opcode & 0x40000000000000) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x80000000000000) != 0;
+        public bool BVal => (_opcode & 0x10000000000000) != 0;
+    }
+
+    struct InstFsetpR
+    {
+        private ulong _opcode;
+        public InstFsetpR(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFsetpI
+    {
+        private ulong _opcode;
+        public InstFsetpI(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFsetpC
+    {
+        private ulong _opcode;
+        public InstFsetpC(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x40) != 0;
+        public bool AbsA => (_opcode & 0x80) != 0;
+        public bool AbsB => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 48) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstFswzadd
+    {
+        private ulong _opcode;
+        public InstFswzadd(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Ftz => (_opcode & 0x100000000000) != 0;
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public bool Ndv => (_opcode & 0x4000000000) != 0;
+        public int PnWord => (int)((_opcode >> 28) & 0xFF);
+    }
+
+    struct InstGetcrsptr
+    {
+        private ulong _opcode;
+        public InstGetcrsptr(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+    }
+
+    struct InstGetlmembase
+    {
+        private ulong _opcode;
+        public InstGetlmembase(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+    }
+
+    struct InstHadd2R
+    {
+        private ulong _opcode;
+        public InstHadd2R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle BSwizzle => (HalfSwizzle)((_opcode >> 28) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x80000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000) != 0;
+        public bool Sat => (_opcode & 0x100000000) != 0;
+        public bool Ftz => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstHadd2I
+    {
+        private ulong _opcode;
+        public InstHadd2I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int BimmH0 => (int)((_opcode >> 20) & 0x3FF);
+        public int BimmH1 => (int)((_opcode >> 47) & 0x200) | (int)((_opcode >> 30) & 0x1FF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public bool Ftz => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstHadd2C
+    {
+        private ulong _opcode;
+        public InstHadd2C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x100000000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public bool Ftz => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstHadd232i
+    {
+        private ulong _opcode;
+        public InstHadd232i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm => (int)(_opcode >> 20);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 53) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public bool Ftz => (_opcode & 0x80000000000000) != 0;
+    }
+
+    struct InstHfma2R
+    {
+        private ulong _opcode;
+        public InstHfma2R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle BSwizzle => (HalfSwizzle)((_opcode >> 28) & 0x3);
+        public HalfSwizzle CSwizzle => (HalfSwizzle)((_opcode >> 35) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000) != 0;
+        public bool NegC => (_opcode & 0x40000000) != 0;
+        public bool Sat => (_opcode & 0x100000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 37) & 0x3);
+    }
+
+    struct InstHfma2I
+    {
+        private ulong _opcode;
+        public InstHfma2I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int BimmH0 => (int)((_opcode >> 20) & 0x3FF);
+        public int BimmH1 => (int)((_opcode >> 47) & 0x200) | (int)((_opcode >> 30) & 0x1FF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle CSwizzle => (HalfSwizzle)((_opcode >> 53) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegC => (_opcode & 0x8000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 57) & 0x3);
+    }
+
+    struct InstHfma2C
+    {
+        private ulong _opcode;
+        public InstHfma2C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle CSwizzle => (HalfSwizzle)((_opcode >> 53) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public bool NegC => (_opcode & 0x8000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 57) & 0x3);
+    }
+
+    struct InstHfma2Rc
+    {
+        private ulong _opcode;
+        public InstHfma2Rc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle CSwizzle => (HalfSwizzle)((_opcode >> 53) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public bool NegC => (_opcode & 0x8000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 57) & 0x3);
+    }
+
+    struct InstHfma232i
+    {
+        private ulong _opcode;
+        public InstHfma232i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm => (int)(_opcode >> 20);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegC => (_opcode & 0x8000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 57) & 0x3);
+    }
+
+    struct InstHmul2R
+    {
+        private ulong _opcode;
+        public InstHmul2R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle BSwizzle => (HalfSwizzle)((_opcode >> 28) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000) != 0;
+        public bool Sat => (_opcode & 0x100000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstHmul2I
+    {
+        private ulong _opcode;
+        public InstHmul2I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int BimmH0 => (int)((_opcode >> 20) & 0x3FF);
+        public int BimmH1 => (int)((_opcode >> 47) & 0x200) | (int)((_opcode >> 30) & 0x1FF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstHmul2C
+    {
+        private ulong _opcode;
+        public InstHmul2C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public OFmt OFmt => (OFmt)((_opcode >> 49) & 0x3);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000000000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstHmul232i
+    {
+        private ulong _opcode;
+        public InstHmul232i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm32 => (int)(_opcode >> 20);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 53) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Sat => (_opcode & 0x10000000000000) != 0;
+        public Fmz Fmz => (Fmz)((_opcode >> 55) & 0x3);
+    }
+
+    struct InstHset2R
+    {
+        private ulong _opcode;
+        public InstHset2R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle BSwizzle => (HalfSwizzle)((_opcode >> 28) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool NegB => (_opcode & 0x80000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000) != 0;
+        public bool Bval => (_opcode & 0x2000000000000) != 0;
+        public FComp Cmp => (FComp)((_opcode >> 35) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool Ftz => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstHset2I
+    {
+        private ulong _opcode;
+        public InstHset2I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int BimmH0 => (int)((_opcode >> 20) & 0x3FF);
+        public int BimmH1 => (int)((_opcode >> 47) & 0x200) | (int)((_opcode >> 30) & 0x1FF);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool Bval => (_opcode & 0x20000000000000) != 0;
+        public FComp Cmp => (FComp)((_opcode >> 49) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool Ftz => (_opcode & 0x40000000000000) != 0;
+    }
+
+    struct InstHset2C
+    {
+        private ulong _opcode;
+        public InstHset2C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool NegB => (_opcode & 0x100000000000000) != 0;
+        public bool Bval => (_opcode & 0x20000000000000) != 0;
+        public FComp Cmp => (FComp)((_opcode >> 49) & 0xF);
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool Ftz => (_opcode & 0x40000000000000) != 0;
+    }
+
+    struct InstHsetp2R
+    {
+        private ulong _opcode;
+        public InstHsetp2R(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x80000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000) != 0;
+        public FComp FComp2 => (FComp)((_opcode >> 35) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x40) != 0;
+        public bool HAnd => (_opcode & 0x2000000000000) != 0;
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+        public HalfSwizzle BSwizzle => (HalfSwizzle)((_opcode >> 28) & 0x3);
+    }
+
+    struct InstHsetp2I
+    {
+        private ulong _opcode;
+        public InstHsetp2I(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int BimmH0 => (int)((_opcode >> 20) & 0x3FF);
+        public int BimmH1 => (int)((_opcode >> 47) & 0x200) | (int)((_opcode >> 30) & 0x1FF);
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 49) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x40) != 0;
+        public bool HAnd => (_opcode & 0x20000000000000) != 0;
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+    }
+
+    struct InstHsetp2C
+    {
+        private ulong _opcode;
+        public InstHsetp2C(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegA => (_opcode & 0x80000000000) != 0;
+        public bool NegB => (_opcode & 0x100000000000000) != 0;
+        public bool AbsA => (_opcode & 0x100000000000) != 0;
+        public bool AbsB => (_opcode & 0x40000000000000) != 0;
+        public FComp FComp => (FComp)((_opcode >> 49) & 0xF);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool Ftz => (_opcode & 0x40) != 0;
+        public bool HAnd => (_opcode & 0x20000000000000) != 0;
+        public HalfSwizzle ASwizzle => (HalfSwizzle)((_opcode >> 47) & 0x3);
+    }
+
+    struct InstI2fR
+    {
+        private ulong _opcode;
+        public InstI2fR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public ISrcFmt ISrcFmt => (ISrcFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+    }
+
+    struct InstI2fI
+    {
+        private ulong _opcode;
+        public InstI2fI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public ISrcFmt ISrcFmt => (ISrcFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+    }
+
+    struct InstI2fC
+    {
+        private ulong _opcode;
+        public InstI2fC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public RoundMode RoundMode => (RoundMode)((_opcode >> 39) & 0x3);
+        public ISrcFmt ISrcFmt => (ISrcFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+        public DstFmt DstFmt => (DstFmt)((_opcode >> 8) & 0x3);
+    }
+
+    struct InstI2iR
+    {
+        private ulong _opcode;
+        public InstI2iR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public ISrcDstFmt IDstFmt => (ISrcDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public ISrcDstFmt ISrcFmt => (ISrcDstFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+    }
+
+    struct InstI2iI
+    {
+        private ulong _opcode;
+        public InstI2iI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public ISrcDstFmt IDstFmt => (ISrcDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public ISrcDstFmt ISrcFmt => (ISrcDstFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+    }
+
+    struct InstI2iC
+    {
+        private ulong _opcode;
+        public InstI2iC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public ISrcDstFmt IDstFmt => (ISrcDstFmt)((int)((_opcode >> 10) & 0x4) | (int)((_opcode >> 8) & 0x3));
+        public ISrcDstFmt ISrcFmt => (ISrcDstFmt)((int)((_opcode >> 11) & 0x4) | (int)((_opcode >> 10) & 0x3));
+    }
+
+    struct InstIaddR
+    {
+        private ulong _opcode;
+        public InstIaddR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIaddI
+    {
+        private ulong _opcode;
+        public InstIaddI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIaddC
+    {
+        private ulong _opcode;
+        public InstIaddC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIadd32i
+    {
+        private ulong _opcode;
+        public InstIadd32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 55) & 0x3);
+        public bool Sat => (_opcode & 0x40000000000000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public bool X => (_opcode & 0x20000000000000) != 0;
+    }
+
+    struct InstIadd3R
+    {
+        private ulong _opcode;
+        public InstIadd3R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x8000000000000) != 0;
+        public bool NegB => (_opcode & 0x4000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool X => (_opcode & 0x1000000000000) != 0;
+        public Lrs Lrs => (Lrs)((_opcode >> 37) & 0x3);
+        public HalfSelect Apart => (HalfSelect)((_opcode >> 35) & 0x3);
+        public HalfSelect Bpart => (HalfSelect)((_opcode >> 33) & 0x3);
+        public HalfSelect Cpart => (HalfSelect)((_opcode >> 31) & 0x3);
+    }
+
+    struct InstIadd3I
+    {
+        private ulong _opcode;
+        public InstIadd3I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x8000000000000) != 0;
+        public bool NegB => (_opcode & 0x4000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool X => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIadd3C
+    {
+        private ulong _opcode;
+        public InstIadd3C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool NegA => (_opcode & 0x8000000000000) != 0;
+        public bool NegB => (_opcode & 0x4000000000000) != 0;
+        public bool NegC => (_opcode & 0x2000000000000) != 0;
+        public bool X => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIcmpR
+    {
+        private ulong _opcode;
+        public InstIcmpR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIcmpI
+    {
+        private ulong _opcode;
+        public InstIcmpI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIcmpC
+    {
+        private ulong _opcode;
+        public InstIcmpC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIcmpRc
+    {
+        private ulong _opcode;
+        public InstIcmpRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstIde
+    {
+        private ulong _opcode;
+        public InstIde(ulong opcode) => _opcode = opcode;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool Di => (_opcode & 0x20) != 0;
+    }
+
+    struct InstIdpR
+    {
+        private ulong _opcode;
+        public InstIdpR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool IsHi => (_opcode & 0x4000000000000) != 0;
+        public bool SrcASign => (_opcode & 0x2000000000000) != 0;
+        public bool IsDp => (_opcode & 0x1000000000000) != 0;
+        public bool SrcBSign => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstIdpC
+    {
+        private ulong _opcode;
+        public InstIdpC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool IsHi => (_opcode & 0x4000000000000) != 0;
+        public bool SrcASign => (_opcode & 0x2000000000000) != 0;
+        public bool IsDp => (_opcode & 0x1000000000000) != 0;
+        public bool SrcBSign => (_opcode & 0x800000000000) != 0;
+    }
+
+    struct InstImadR
+    {
+        private ulong _opcode;
+        public InstImadR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Hilo => (_opcode & 0x40000000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 51) & 0x3);
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool X => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstImadI
+    {
+        private ulong _opcode;
+        public InstImadI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Hilo => (_opcode & 0x40000000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 51) & 0x3);
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool X => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstImadC
+    {
+        private ulong _opcode;
+        public InstImadC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Hilo => (_opcode & 0x40000000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 51) & 0x3);
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool X => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstImadRc
+    {
+        private ulong _opcode;
+        public InstImadRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Hilo => (_opcode & 0x40000000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 51) & 0x3);
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool X => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstImad32i
+    {
+        private ulong _opcode;
+        public InstImad32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool BSigned => (_opcode & 0x200000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 55) & 0x3);
+        public bool ASigned => (_opcode & 0x40000000000000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public bool Hilo => (_opcode & 0x20000000000000) != 0;
+    }
+
+    struct InstImadspR
+    {
+        private ulong _opcode;
+        public InstImadspR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ImadspASelect ASelect => (ImadspASelect)((_opcode >> 48) & 0x7);
+        public ImadspBSelect BSelect => (ImadspBSelect)((_opcode >> 53) & 0x3);
+        public ImadspASelect CSelect => (ImadspASelect)((int)((_opcode >> 50) & 0x6) | (int)((_opcode >> 48) & 0x1));
+    }
+
+    struct InstImadspI
+    {
+        private ulong _opcode;
+        public InstImadspI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ImadspASelect ASelect => (ImadspASelect)((_opcode >> 48) & 0x7);
+        public ImadspBSelect BSelect => (ImadspBSelect)((_opcode >> 53) & 0x3);
+        public ImadspASelect CSelect => (ImadspASelect)((int)((_opcode >> 50) & 0x6) | (int)((_opcode >> 48) & 0x1));
+    }
+
+    struct InstImadspC
+    {
+        private ulong _opcode;
+        public InstImadspC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ImadspASelect ASelect => (ImadspASelect)((_opcode >> 48) & 0x7);
+        public ImadspBSelect BSelect => (ImadspBSelect)((_opcode >> 53) & 0x3);
+        public ImadspASelect CSelect => (ImadspASelect)((int)((_opcode >> 50) & 0x6) | (int)((_opcode >> 48) & 0x1));
+    }
+
+    struct InstImadspRc
+    {
+        private ulong _opcode;
+        public InstImadspRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ImadspASelect ASelect => (ImadspASelect)((_opcode >> 48) & 0x7);
+        public ImadspBSelect BSelect => (ImadspBSelect)((_opcode >> 53) & 0x3);
+        public ImadspASelect CSelect => (ImadspASelect)((int)((_opcode >> 50) & 0x6) | (int)((_opcode >> 48) & 0x1));
+    }
+
+    struct InstImnmxR
+    {
+        private ulong _opcode;
+        public InstImnmxR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstImnmxI
+    {
+        private ulong _opcode;
+        public InstImnmxI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstImnmxC
+    {
+        private ulong _opcode;
+        public InstImnmxC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstImulR
+    {
+        private ulong _opcode;
+        public InstImulR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool ASigned => (_opcode & 0x10000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000) != 0;
+        public bool Hilo => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstImulI
+    {
+        private ulong _opcode;
+        public InstImulI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool ASigned => (_opcode & 0x10000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000) != 0;
+        public bool Hilo => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstImulC
+    {
+        private ulong _opcode;
+        public InstImulC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool ASigned => (_opcode & 0x10000000000) != 0;
+        public bool BSigned => (_opcode & 0x20000000000) != 0;
+        public bool Hilo => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstImul32i
+    {
+        private ulong _opcode;
+        public InstImul32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool ASigned => (_opcode & 0x40000000000000) != 0;
+        public bool BSigned => (_opcode & 0x80000000000000) != 0;
+        public bool Hilo => (_opcode & 0x20000000000000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+    }
+
+    struct InstIpa
+    {
+        private ulong _opcode;
+        public InstIpa(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IpaOp IpaOp => (IpaOp)((_opcode >> 54) & 0x3);
+        public int Msi => (int)((_opcode >> 52) & 0x3);
+        public bool Sat => (_opcode & 0x8000000000000) != 0;
+        public bool Idx => (_opcode & 0x4000000000) != 0;
+        public int Imm10 => (int)((_opcode >> 28) & 0x3FF);
+        public int SrcPred => (int)((_opcode >> 47) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstIsberd
+    {
+        private ulong _opcode;
+        public InstIsberd(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public AlSize AlSize => (AlSize)((_opcode >> 47) & 0x3);
+        public IBase IBase => (IBase)((_opcode >> 33) & 0x3);
+        public bool O => (_opcode & 0x100000000) != 0;
+        public bool P => (_opcode & 0x80000000) != 0;
+    }
+
+    struct InstIscaddR
+    {
+        private ulong _opcode;
+        public InstIscaddR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int Imm5 => (int)((_opcode >> 39) & 0x1F);
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+    }
+
+    struct InstIscaddI
+    {
+        private ulong _opcode;
+        public InstIscaddI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int Imm5 => (int)((_opcode >> 39) & 0x1F);
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+    }
+
+    struct InstIscaddC
+    {
+        private ulong _opcode;
+        public InstIscaddC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int Imm5 => (int)((_opcode >> 39) & 0x1F);
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 48) & 0x3);
+    }
+
+    struct InstIscadd32i
+    {
+        private ulong _opcode;
+        public InstIscadd32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public int Imm5 => (int)((_opcode >> 53) & 0x1F);
+    }
+
+    struct InstIsetR
+    {
+        private ulong _opcode;
+        public InstIsetR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool BVal => (_opcode & 0x100000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIsetI
+    {
+        private ulong _opcode;
+        public InstIsetI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool BVal => (_opcode & 0x100000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIsetC
+    {
+        private ulong _opcode;
+        public InstIsetC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public bool BVal => (_opcode & 0x100000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+    }
+
+    struct InstIsetpR
+    {
+        private ulong _opcode;
+        public InstIsetpR(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstIsetpI
+    {
+        private ulong _opcode;
+        public InstIsetpI(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstIsetpC
+    {
+        private ulong _opcode;
+        public InstIsetpC(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public IComp IComp => (IComp)((_opcode >> 49) & 0x7);
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public BoolOp Bop => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+    }
+
+    struct InstJcal
+    {
+        private ulong _opcode;
+        public InstJcal(ulong opcode) => _opcode = opcode;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool Ca => (_opcode & 0x20) != 0;
+        public bool Inc => (_opcode & 0x40) != 0;
+    }
+
+    struct InstJmp
+    {
+        private ulong _opcode;
+        public InstJmp(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+        public bool Ca => (_opcode & 0x20) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool Lmt => (_opcode & 0x40) != 0;
+        public bool U => (_opcode & 0x80) != 0;
+    }
+
+    struct InstJmx
+    {
+        private ulong _opcode;
+        public InstJmx(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+        public bool Ca => (_opcode & 0x20) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool Lmt => (_opcode & 0x40) != 0;
+    }
+
+    struct InstKil
+    {
+        private ulong _opcode;
+        public InstKil(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstLd
+    {
+        private ulong _opcode;
+        public InstLd(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 58) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 56) & 0x3);
+        public LsSize LsSize => (LsSize)((_opcode >> 53) & 0x7);
+        public bool E => (_opcode & 0x10000000000000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+    }
+
+    struct InstLdc
+    {
+        private ulong _opcode;
+        public InstLdc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public AddressMode AddressMode => (AddressMode)((_opcode >> 44) & 0x3);
+        public int CbufSlot => (int)((_opcode >> 36) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0xFFFF);
+    }
+
+    struct InstLdg
+    {
+        private ulong _opcode;
+        public InstLdg(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize LsSize => (LsSize)((_opcode >> 48) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 46) & 0x3);
+        public bool E => (_opcode & 0x200000000000) != 0;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstLdl
+    {
+        private ulong _opcode;
+        public InstLdl(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public CacheOp2 CacheOp => (CacheOp2)((_opcode >> 44) & 0x3);
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstLds
+    {
+        private ulong _opcode;
+        public InstLds(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public bool U => (_opcode & 0x100000000000) != 0;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstLeaR
+    {
+        private ulong _opcode;
+        public InstLeaR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x400000000000) != 0;
+        public bool NegA => (_opcode & 0x200000000000) != 0;
+        public int ImmU5 => (int)((_opcode >> 39) & 0x1F);
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstLeaI
+    {
+        private ulong _opcode;
+        public InstLeaI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x400000000000) != 0;
+        public bool NegA => (_opcode & 0x200000000000) != 0;
+        public int ImmU5 => (int)((_opcode >> 39) & 0x1F);
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstLeaC
+    {
+        private ulong _opcode;
+        public InstLeaC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x400000000000) != 0;
+        public bool NegA => (_opcode & 0x200000000000) != 0;
+        public int ImmU5 => (int)((_opcode >> 39) & 0x1F);
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstLeaHiR
+    {
+        private ulong _opcode;
+        public InstLeaHiR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x4000000000) != 0;
+        public bool NegA => (_opcode & 0x2000000000) != 0;
+        public int ImmU5 => (int)((_opcode >> 28) & 0x1F);
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstLeaHiC
+    {
+        private ulong _opcode;
+        public InstLeaHiC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x200000000000000) != 0;
+        public bool NegA => (_opcode & 0x100000000000000) != 0;
+        public int ImmU5 => (int)((_opcode >> 51) & 0x1F);
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstLepc
+    {
+        private ulong _opcode;
+        public InstLepc(ulong opcode) => _opcode = opcode;
+    }
+
+    struct InstLongjmp
+    {
+        private ulong _opcode;
+        public InstLongjmp(ulong opcode) => _opcode = opcode;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstLopR
+    {
+        private ulong _opcode;
+        public InstLopR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+        public PredicateOp PredicateOp => (PredicateOp)((_opcode >> 44) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public LogicOp Lop => (LogicOp)((_opcode >> 41) & 0x3);
+        public bool NegA => (_opcode & 0x8000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstLopI
+    {
+        private ulong _opcode;
+        public InstLopI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+        public PredicateOp PredicateOp => (PredicateOp)((_opcode >> 44) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public LogicOp LogicOp => (LogicOp)((_opcode >> 41) & 0x3);
+        public bool NegA => (_opcode & 0x8000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstLopC
+    {
+        private ulong _opcode;
+        public InstLopC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+        public PredicateOp PredicateOp => (PredicateOp)((_opcode >> 44) & 0x3);
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public LogicOp LogicOp => (LogicOp)((_opcode >> 41) & 0x3);
+        public bool NegA => (_opcode & 0x8000000000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstLop3R
+    {
+        private ulong _opcode;
+        public InstLop3R(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+        public PredicateOp PredicateOp => (PredicateOp)((_opcode >> 36) & 0x3);
+        public bool X => (_opcode & 0x4000000000) != 0;
+        public int Imm => (int)((_opcode >> 28) & 0xFF);
+    }
+
+    struct InstLop3I
+    {
+        private ulong _opcode;
+        public InstLop3I(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x200000000000000) != 0;
+        public int Imm => (int)((_opcode >> 48) & 0xFF);
+    }
+
+    struct InstLop3C
+    {
+        private ulong _opcode;
+        public InstLop3C(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x100000000000000) != 0;
+        public int Imm => (int)((_opcode >> 48) & 0xFF);
+    }
+
+    struct InstLop32i
+    {
+        private ulong _opcode;
+        public InstLop32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x10000000000000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+        public bool X => (_opcode & 0x200000000000000) != 0;
+        public LogicOp LogicOp => (LogicOp)((_opcode >> 53) & 0x3);
+        public bool NegA => (_opcode & 0x80000000000000) != 0;
+        public bool NegB => (_opcode & 0x100000000000000) != 0;
+    }
+
+    struct InstMembar
+    {
+        private ulong _opcode;
+        public InstMembar(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Membar Membar => (Membar)((_opcode >> 8) & 0x3);
+        public Ivall Ivall => (Ivall)((_opcode >> 0) & 0x3);
+    }
+
+    struct InstMovR
+    {
+        private ulong _opcode;
+        public InstMovR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int QuadMask => (int)((_opcode >> 39) & 0xF);
+    }
+
+    struct InstMovI
+    {
+        private ulong _opcode;
+        public InstMovI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int QuadMask => (int)((_opcode >> 39) & 0xF);
+    }
+
+    struct InstMovC
+    {
+        private ulong _opcode;
+        public InstMovC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int QuadMask => (int)((_opcode >> 39) & 0xF);
+    }
+
+    struct InstMov32i
+    {
+        private ulong _opcode;
+        public InstMov32i(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm32 => (int)(_opcode >> 20);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int QuadMask => (int)((_opcode >> 12) & 0xF);
+    }
+
+    struct InstMufu
+    {
+        private ulong _opcode;
+        public InstMufu(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public MufuOp MufuOp => (MufuOp)((_opcode >> 20) & 0xF);
+        public bool AbsA => (_opcode & 0x400000000000) != 0;
+        public bool NegA => (_opcode & 0x1000000000000) != 0;
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstNop
+    {
+        private ulong _opcode;
+        public InstNop(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool Trig => (_opcode & 0x2000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 8) & 0x1F);
+    }
+
+    struct InstOutR
+    {
+        private ulong _opcode;
+        public InstOutR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public OutType OutType => (OutType)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstOutI
+    {
+        private ulong _opcode;
+        public InstOutI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public OutType OutType => (OutType)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstOutC
+    {
+        private ulong _opcode;
+        public InstOutC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public OutType OutType => (OutType)((_opcode >> 39) & 0x3);
+    }
+
+    struct InstP2rR
+    {
+        private ulong _opcode;
+        public InstP2rR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstP2rI
+    {
+        private ulong _opcode;
+        public InstP2rI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstP2rC
+    {
+        private ulong _opcode;
+        public InstP2rC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstPbk
+    {
+        private ulong _opcode;
+        public InstPbk(ulong opcode) => _opcode = opcode;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+    }
+
+    struct InstPcnt
+    {
+        private ulong _opcode;
+        public InstPcnt(ulong opcode) => _opcode = opcode;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+    }
+
+    struct InstPexit
+    {
+        private ulong _opcode;
+        public InstPexit(ulong opcode) => _opcode = opcode;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstPixld
+    {
+        private ulong _opcode;
+        public InstPixld(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int DestPred => (int)((_opcode >> 45) & 0x7);
+        public PixMode PixMode => (PixMode)((_opcode >> 31) & 0x7);
+        public int Imm8 => (int)((_opcode >> 20) & 0xFF);
+    }
+
+    struct InstPlongjmp
+    {
+        private ulong _opcode;
+        public InstPlongjmp(ulong opcode) => _opcode = opcode;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+    }
+
+    struct InstPopcR
+    {
+        private ulong _opcode;
+        public InstPopcR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstPopcI
+    {
+        private ulong _opcode;
+        public InstPopcI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstPopcC
+    {
+        private ulong _opcode;
+        public InstPopcC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool NegB => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstPret
+    {
+        private ulong _opcode;
+        public InstPret(ulong opcode) => _opcode = opcode;
+        public bool Ca => (_opcode & 0x20) != 0;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Inc => (_opcode & 0x40) != 0;
+    }
+
+    struct InstPrmtR
+    {
+        private ulong _opcode;
+        public InstPrmtR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public PMode PMode => (PMode)((_opcode >> 48) & 0xF);
+    }
+
+    struct InstPrmtI
+    {
+        private ulong _opcode;
+        public InstPrmtI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public PMode PMode => (PMode)((_opcode >> 48) & 0xF);
+    }
+
+    struct InstPrmtC
+    {
+        private ulong _opcode;
+        public InstPrmtC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public PMode PMode => (PMode)((_opcode >> 48) & 0xF);
+    }
+
+    struct InstPrmtRc
+    {
+        private ulong _opcode;
+        public InstPrmtRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public PMode PMode => (PMode)((_opcode >> 48) & 0xF);
+    }
+
+    struct InstPset
+    {
+        private ulong _opcode;
+        public InstPset(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int Src2Pred => (int)((_opcode >> 12) & 0x7);
+        public bool Src2PredInv => (_opcode & 0x8000) != 0;
+        public int Src1Pred => (int)((_opcode >> 29) & 0x7);
+        public bool Src1PredInv => (_opcode & 0x100000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp BoolOpAB => (BoolOp)((_opcode >> 24) & 0x3);
+        public BoolOp BoolOpC => (BoolOp)((_opcode >> 45) & 0x3);
+        public bool BVal => (_opcode & 0x100000000000) != 0;
+    }
+
+    struct InstPsetp
+    {
+        private ulong _opcode;
+        public InstPsetp(ulong opcode) => _opcode = opcode;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public int Src2Pred => (int)((_opcode >> 12) & 0x7);
+        public bool Src2PredInv => (_opcode & 0x8000) != 0;
+        public int Src1Pred => (int)((_opcode >> 29) & 0x7);
+        public bool Src1PredInv => (_opcode & 0x100000000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public BoolOp BoolOpAB => (BoolOp)((_opcode >> 24) & 0x3);
+        public BoolOp BoolOpC => (BoolOp)((_opcode >> 45) & 0x3);
+    }
+
+    struct InstR2b
+    {
+        private ulong _opcode;
+        public InstR2b(ulong opcode) => _opcode = opcode;
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public BarMode Mode => (BarMode)((_opcode >> 32) & 0x3);
+        public int Name => (int)((_opcode >> 28) & 0xF);
+    }
+
+    struct InstR2pR
+    {
+        private ulong _opcode;
+        public InstR2pR(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstR2pI
+    {
+        private ulong _opcode;
+        public InstR2pI(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstR2pC
+    {
+        private ulong _opcode;
+        public InstR2pC(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ByteSel ByteSel => (ByteSel)((_opcode >> 41) & 0x3);
+        public bool Ccpr => (_opcode & 0x10000000000) != 0;
+    }
+
+    struct InstRam
+    {
+        private ulong _opcode;
+        public InstRam(ulong opcode) => _opcode = opcode;
+    }
+
+    struct InstRed
+    {
+        private ulong _opcode;
+        public InstRed(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm20 => (int)((_opcode >> 28) & 0xFFFFF);
+        public AtomSize RedSize => (AtomSize)((_opcode >> 20) & 0x7);
+        public RedOp RedOp => (RedOp)((_opcode >> 23) & 0x7);
+        public bool E => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstRet
+    {
+        private ulong _opcode;
+        public InstRet(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstRroR
+    {
+        private ulong _opcode;
+        public InstRroR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool RroOp => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstRroI
+    {
+        private ulong _opcode;
+        public InstRroI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool RroOp => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstRroC
+    {
+        private ulong _opcode;
+        public InstRroC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool AbsB => (_opcode & 0x2000000000000) != 0;
+        public bool NegB => (_opcode & 0x200000000000) != 0;
+        public bool RroOp => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstRtt
+    {
+        private ulong _opcode;
+        public InstRtt(ulong opcode) => _opcode = opcode;
+    }
+
+    struct InstS2r
+    {
+        private ulong _opcode;
+        public InstS2r(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public SReg SReg => (SReg)((_opcode >> 20) & 0xFF);
+    }
+
+    struct InstSam
+    {
+        private ulong _opcode;
+        public InstSam(ulong opcode) => _opcode = opcode;
+    }
+
+    struct InstSelR
+    {
+        private ulong _opcode;
+        public InstSelR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstSelI
+    {
+        private ulong _opcode;
+        public InstSelI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstSelC
+    {
+        private ulong _opcode;
+        public InstSelC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+    }
+
+    struct InstSetcrsptr
+    {
+        private ulong _opcode;
+        public InstSetcrsptr(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+    }
+
+    struct InstSetlmembase
+    {
+        private ulong _opcode;
+        public InstSetlmembase(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+    }
+
+    struct InstShfLR
+    {
+        private ulong _opcode;
+        public InstShfLR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool M => (_opcode & 0x4000000000000) != 0;
+        public XModeShf XModeShf => (XModeShf)((_opcode >> 48) & 0x3);
+        public MaxShift MaxShift => (MaxShift)((_opcode >> 37) & 0x3);
+    }
+
+    struct InstShfRR
+    {
+        private ulong _opcode;
+        public InstShfRR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool M => (_opcode & 0x4000000000000) != 0;
+        public XModeShf XModeShf => (XModeShf)((_opcode >> 48) & 0x3);
+        public MaxShift MaxShift => (MaxShift)((_opcode >> 37) & 0x3);
+    }
+
+    struct InstShfLI
+    {
+        private ulong _opcode;
+        public InstShfLI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool M => (_opcode & 0x4000000000000) != 0;
+        public XModeShf XModeShf => (XModeShf)((_opcode >> 48) & 0x3);
+        public MaxShift MaxShift => (MaxShift)((_opcode >> 37) & 0x3);
+        public int Imm6 => (int)((_opcode >> 20) & 0x3F);
+    }
+
+    struct InstShfRI
+    {
+        private ulong _opcode;
+        public InstShfRI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool M => (_opcode & 0x4000000000000) != 0;
+        public XModeShf XModeShf => (XModeShf)((_opcode >> 48) & 0x3);
+        public MaxShift MaxShift => (MaxShift)((_opcode >> 37) & 0x3);
+        public int Imm6 => (int)((_opcode >> 20) & 0x3F);
+    }
+
+    struct InstShfl
+    {
+        private ulong _opcode;
+        public InstShfl(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int SrcBImm => (int)((_opcode >> 20) & 0x1F);
+        public int SrcCImm => (int)((_opcode >> 34) & 0x1FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public ShflMode ShflMode => (ShflMode)((_opcode >> 30) & 0x3);
+        public bool CFixShfl => (_opcode & 0x20000000) != 0;
+        public bool BFixShfl => (_opcode & 0x10000000) != 0;
+        public int DestPred => (int)((_opcode >> 48) & 0x7);
+    }
+
+    struct InstShlR
+    {
+        private ulong _opcode;
+        public InstShlR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstShlI
+    {
+        private ulong _opcode;
+        public InstShlI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstShlC
+    {
+        private ulong _opcode;
+        public InstShlC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x80000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstShrR
+    {
+        private ulong _opcode;
+        public InstShrR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstShrI
+    {
+        private ulong _opcode;
+        public InstShrI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Imm20 => (int)((_opcode >> 37) & 0x80000) | (int)((_opcode >> 20) & 0x7FFFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstShrC
+    {
+        private ulong _opcode;
+        public InstShrC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Signed => (_opcode & 0x1000000000000) != 0;
+        public XMode XMode => (XMode)((_opcode >> 43) & 0x3);
+        public bool Brev => (_opcode & 0x10000000000) != 0;
+        public bool M => (_opcode & 0x8000000000) != 0;
+    }
+
+    struct InstSsy
+    {
+        private ulong _opcode;
+        public InstSsy(ulong opcode) => _opcode = opcode;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+        public bool Ca => (_opcode & 0x20) != 0;
+    }
+
+    struct InstSt
+    {
+        private ulong _opcode;
+        public InstSt(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 58) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 56) & 0x3);
+        public LsSize LsSize => (LsSize)((_opcode >> 53) & 0x7);
+        public bool E => (_opcode & 0x10000000000000) != 0;
+        public int Imm32 => (int)(_opcode >> 20);
+    }
+
+    struct InstStg
+    {
+        private ulong _opcode;
+        public InstStg(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 46) & 0x3);
+        public bool E => (_opcode & 0x200000000000) != 0;
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstStl
+    {
+        private ulong _opcode;
+        public InstStl(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 44) & 0x3);
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstStp
+    {
+        private ulong _opcode;
+        public InstStp(ulong opcode) => _opcode = opcode;
+        public bool Wait => (_opcode & 0x80000000) != 0;
+        public int Imm8 => (int)((_opcode >> 20) & 0xFF);
+    }
+
+    struct InstSts
+    {
+        private ulong _opcode;
+        public InstSts(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public LsSize2 LsSize => (LsSize2)((_opcode >> 48) & 0x7);
+        public int Imm24 => (int)((_opcode >> 20) & 0xFFFFFF);
+    }
+
+    struct InstSuatomB
+    {
+        private ulong _opcode;
+        public InstSuatomB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuatomSize Size => (SuatomSize)((_opcode >> 36) & 0x7);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public SuatomOp Op => (SuatomOp)((_opcode >> 29) & 0xF);
+        public bool Ba => (_opcode & 0x10000000) != 0;
+    }
+
+    struct InstSuatom
+    {
+        private ulong _opcode;
+        public InstSuatom(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public SuatomSize Size => (SuatomSize)((_opcode >> 51) & 0x7);
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public SuatomOp Op => (SuatomOp)((_opcode >> 29) & 0xF);
+        public bool Ba => (_opcode & 0x10000000) != 0;
+    }
+
+    struct InstSuatomB2
+    {
+        private ulong _opcode;
+        public InstSuatomB2(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuatomSize Size => (SuatomSize)((_opcode >> 36) & 0x7);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public SuatomOp Op => (SuatomOp)((_opcode >> 29) & 0xF);
+        public bool Ba => (_opcode & 0x10000000) != 0;
+    }
+
+    struct InstSuatomCasB
+    {
+        private ulong _opcode;
+        public InstSuatomCasB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuatomSize Size => (SuatomSize)((_opcode >> 36) & 0x7);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred => (int)((_opcode >> 30) & 0x7);
+        public bool Ba => (_opcode & 0x10000000) != 0;
+    }
+
+    struct InstSuatomCas
+    {
+        private ulong _opcode;
+        public InstSuatomCas(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public SuatomSize Size => (SuatomSize)((_opcode >> 51) & 0x7);
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred => (int)((_opcode >> 30) & 0x7);
+        public bool Ba => (_opcode & 0x10000000) != 0;
+    }
+
+    struct InstSuldDB
+    {
+        private ulong _opcode;
+        public InstSuldDB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred2 => (int)((_opcode >> 30) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 24) & 0x3);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuSize Size => (SuSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSuldD
+    {
+        private ulong _opcode;
+        public InstSuldD(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred2 => (int)((_opcode >> 30) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 24) & 0x3);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuSize Size => (SuSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSuldB
+    {
+        private ulong _opcode;
+        public InstSuldB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred2 => (int)((_opcode >> 30) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 24) & 0x3);
+        public SuRgba Rgba => (SuRgba)((_opcode >> 20) & 0xF);
+    }
+
+    struct InstSuld
+    {
+        private ulong _opcode;
+        public InstSuld(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public int DestPred2 => (int)((_opcode >> 30) & 0x7);
+        public CacheOpLd CacheOp => (CacheOpLd)((_opcode >> 24) & 0x3);
+        public SuRgba Rgba => (SuRgba)((_opcode >> 20) & 0xF);
+    }
+
+    struct InstSuredB
+    {
+        private ulong _opcode;
+        public InstSuredB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public RedOp Op => (RedOp)((_opcode >> 24) & 0x7);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuatomSize Size => (SuatomSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSured
+    {
+        private ulong _opcode;
+        public InstSured(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public RedOp Op => (RedOp)((_opcode >> 24) & 0x7);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuatomSize Size => (SuatomSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSustDB
+    {
+        private ulong _opcode;
+        public InstSustDB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 24) & 0x3);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuSize Size => (SuSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSustD
+    {
+        private ulong _opcode;
+        public InstSustD(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 24) & 0x3);
+        public bool Ba => (_opcode & 0x800000) != 0;
+        public SuSize Size => (SuSize)((_opcode >> 20) & 0x7);
+    }
+
+    struct InstSustB
+    {
+        private ulong _opcode;
+        public InstSustB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 24) & 0x3);
+        public SuRgba Rgba => (SuRgba)((_opcode >> 20) & 0xF);
+    }
+
+    struct InstSust
+    {
+        private ulong _opcode;
+        public InstSust(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Clamp Clamp => (Clamp)((_opcode >> 49) & 0x3);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public SuDim Dim => (SuDim)((_opcode >> 33) & 0x7);
+        public CacheOpSt CacheOp => (CacheOpSt)((_opcode >> 24) & 0x3);
+        public SuRgba Rgba => (SuRgba)((_opcode >> 20) & 0xF);
+    }
+
+    struct InstSync
+    {
+        private ulong _opcode;
+        public InstSync(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public Ccc Ccc => (Ccc)((_opcode >> 0) & 0x1F);
+    }
+
+    struct InstTex
+    {
+        private ulong _opcode;
+        public InstTex(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Lc => (_opcode & 0x400000000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public Lod Lod => (Lod)((_opcode >> 55) & 0x7);
+        public bool Aoffi => (_opcode & 0x40000000000000) != 0;
+        public bool Dc => (_opcode & 0x4000000000000) != 0;
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+    }
+
+    struct InstTexB
+    {
+        private ulong _opcode;
+        public InstTexB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Lcb => (_opcode & 0x10000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public Lod Lodb => (Lod)((_opcode >> 37) & 0x7);
+        public bool Aoffib => (_opcode & 0x1000000000) != 0;
+        public bool Dc => (_opcode & 0x4000000000000) != 0;
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+    }
+
+    struct InstTexs
+    {
+        private ulong _opcode;
+        public InstTexs(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public TexsTarget Target => (TexsTarget)((_opcode >> 53) & 0xF);
+        public int WMask => (int)((_opcode >> 50) & 0x7);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int Dest2 => (int)((_opcode >> 28) & 0xFF);
+    }
+
+    struct InstTld
+    {
+        private ulong _opcode;
+        public InstTld(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Lod => (_opcode & 0x80000000000000) != 0;
+        public bool Toff => (_opcode & 0x800000000) != 0;
+        public bool Ms => (_opcode & 0x4000000000000) != 0;
+        public bool Cl => (_opcode & 0x40000000000000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTldB
+    {
+        private ulong _opcode;
+        public InstTldB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Lod => (_opcode & 0x80000000000000) != 0;
+        public bool Toff => (_opcode & 0x800000000) != 0;
+        public bool Ms => (_opcode & 0x4000000000000) != 0;
+        public bool Cl => (_opcode & 0x40000000000000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTlds
+    {
+        private ulong _opcode;
+        public InstTlds(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public TldsTarget Target => (TldsTarget)((_opcode >> 53) & 0xF);
+        public int WMask => (int)((_opcode >> 50) & 0x7);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int Dest2 => (int)((_opcode >> 28) & 0xFF);
+    }
+
+    struct InstTld4
+    {
+        private ulong _opcode;
+        public InstTld4(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Lc => (_opcode & 0x400000000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public TexComp TexComp => (TexComp)((_opcode >> 56) & 0x3);
+        public TexOffset Toff => (TexOffset)((_opcode >> 54) & 0x3);
+        public bool Dc => (_opcode & 0x4000000000000) != 0;
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+    }
+
+    struct InstTld4B
+    {
+        private ulong _opcode;
+        public InstTld4B(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Lc => (_opcode & 0x10000000000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public TexComp TexComp => (TexComp)((_opcode >> 38) & 0x3);
+        public TexOffset Toff => (TexOffset)((_opcode >> 36) & 0x3);
+        public bool Dc => (_opcode & 0x4000000000000) != 0;
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+    }
+
+    struct InstTld4s
+    {
+        private ulong _opcode;
+        public InstTld4s(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public TexComp TexComp => (TexComp)((_opcode >> 52) & 0x3);
+        public bool Aoffi => (_opcode & 0x8000000000000) != 0;
+        public bool Dc => (_opcode & 0x4000000000000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int Dest2 => (int)((_opcode >> 28) & 0xFF);
+    }
+
+    struct InstTmml
+    {
+        private ulong _opcode;
+        public InstTmml(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTmmlB
+    {
+        private ulong _opcode;
+        public InstTmmlB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTxa
+    {
+        private ulong _opcode;
+        public InstTxa(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public bool Ndv => (_opcode & 0x800000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+    }
+
+    struct InstTxd
+    {
+        private ulong _opcode;
+        public InstTxd(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public bool Lc => (_opcode & 0x4000000000000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public bool Toff => (_opcode & 0x800000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTxdB
+    {
+        private ulong _opcode;
+        public InstTxdB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int DestPred => (int)((_opcode >> 51) & 0x7);
+        public bool Lc => (_opcode & 0x4000000000000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public bool Toff => (_opcode & 0x800000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexDim Dim => (TexDim)((_opcode >> 28) & 0x7);
+    }
+
+    struct InstTxq
+    {
+        private ulong _opcode;
+        public InstTxq(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int TidB => (int)((_opcode >> 36) & 0x1FFF);
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexQuery TexQuery => (TexQuery)((_opcode >> 22) & 0x3F);
+    }
+
+    struct InstTxqB
+    {
+        private ulong _opcode;
+        public InstTxqB(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool Nodep => (_opcode & 0x2000000000000) != 0;
+        public int WMask => (int)((_opcode >> 31) & 0xF);
+        public TexQuery TexQuery => (TexQuery)((_opcode >> 22) & 0x3F);
+    }
+
+    struct InstVabsdiff
+    {
+        private ulong _opcode;
+        public InstVabsdiff(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool DFormat => (_opcode & 0x40000000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVabsdiff4
+    {
+        private ulong _opcode;
+        public InstVabsdiff4(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public VideoRed VRed => (VideoRed)((_opcode >> 53) & 0x3);
+        public LaneMask4 LaneMask4 => (LaneMask4)((int)((_opcode >> 49) & 0xC) | (int)((_opcode >> 36) & 0x3));
+        public bool Sat => (_opcode & 0x4000000000000) != 0;
+        public bool SrcBFmt => (_opcode & 0x2000000000000) != 0;
+        public bool SrcAFmt => (_opcode & 0x1000000000000) != 0;
+        public bool DFormat => (_opcode & 0x4000000000) != 0;
+        public ASelect4 Asel4 => (ASelect4)((_opcode >> 32) & 0xF);
+        public BSelect4 Bsel4 => (BSelect4)((_opcode >> 28) & 0xF);
+    }
+
+    struct InstVadd
+    {
+        private ulong _opcode;
+        public InstVadd(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 56) & 0x3);
+        public bool DFormat => (_opcode & 0x40000000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVmad
+    {
+        private ulong _opcode;
+        public InstVmad(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public AvgMode AvgMode => (AvgMode)((_opcode >> 53) & 0x3);
+        public VideoScale VideoScale => (VideoScale)((_opcode >> 51) & 0x3);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVmnmx
+    {
+        private ulong _opcode;
+        public InstVmnmx(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool DFormat => (_opcode & 0x40000000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool Mn => (_opcode & 0x100000000000000) != 0;
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVote
+    {
+        private ulong _opcode;
+        public InstVote(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public VoteMode VoteMode => (VoteMode)((_opcode >> 48) & 0x3);
+        public int VpDest => (int)((_opcode >> 45) & 0x7);
+    }
+
+    struct InstVotevtg
+    {
+        private ulong _opcode;
+        public InstVotevtg(ulong opcode) => _opcode = opcode;
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public VoteMode VoteMode => (VoteMode)((_opcode >> 48) & 0x3);
+        public int Imm28 => (int)((_opcode >> 20) & 0xFFFFFFF);
+    }
+
+    struct InstVset
+    {
+        private ulong _opcode;
+        public InstVset(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public IComp VComp => (IComp)((_opcode >> 54) & 0x7);
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVsetp
+    {
+        private ulong _opcode;
+        public InstVsetp(ulong opcode) => _opcode = opcode;
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((int)((_opcode >> 46) & 0x8) | (int)((_opcode >> 28) & 0x7));
+        public IComp VComp => (IComp)((int)((_opcode >> 45) & 0x4) | (int)((_opcode >> 43) & 0x3));
+        public BoolOp BoolOp => (BoolOp)((_opcode >> 45) & 0x3);
+        public int SrcPred => (int)((_opcode >> 39) & 0x7);
+        public bool SrcPredInv => (_opcode & 0x40000000000) != 0;
+        public int DestPred => (int)((_opcode >> 3) & 0x7);
+        public int DestPredInv => (int)((_opcode >> 0) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVshl
+    {
+        private ulong _opcode;
+        public InstVshl(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Mv => (_opcode & 0x2000000000000) != 0;
+        public bool DFormat => (_opcode & 0x40000000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((_opcode >> 28) & 0x7);
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstVshr
+    {
+        private ulong _opcode;
+        public InstVshr(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Mv => (_opcode & 0x2000000000000) != 0;
+        public bool DFormat => (_opcode & 0x40000000000000) != 0;
+        public VectorSelect ASelect => (VectorSelect)((int)((_opcode >> 45) & 0x8) | (int)((_opcode >> 36) & 0x7));
+        public VectorSelect BSelect => (VectorSelect)((_opcode >> 28) & 0x7);
+        public bool Sat => (_opcode & 0x80000000000000) != 0;
+        public VideoOp VideoOp => (VideoOp)((_opcode >> 51) & 0x7);
+        public bool BVideo => (_opcode & 0x4000000000000) != 0;
+    }
+
+    struct InstXmadR
+    {
+        private ulong _opcode;
+        public InstXmadR(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcB => (int)((_opcode >> 20) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool HiloA => (_opcode & 0x20000000000000) != 0;
+        public XmadCop XmadCop => (XmadCop)((_opcode >> 50) & 0x7);
+        public bool BSigned => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+        public bool X => (_opcode & 0x4000000000) != 0;
+        public bool Mrg => (_opcode & 0x2000000000) != 0;
+        public bool Psl => (_opcode & 0x1000000000) != 0;
+        public bool HiloB => (_opcode & 0x800000000) != 0;
+    }
+
+    struct InstXmadI
+    {
+        private ulong _opcode;
+        public InstXmadI(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public int Imm16 => (int)((_opcode >> 20) & 0xFFFF);
+        public bool HiloA => (_opcode & 0x20000000000000) != 0;
+        public XmadCop XmadCop => (XmadCop)((_opcode >> 50) & 0x7);
+        public bool BSigned => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+        public bool X => (_opcode & 0x4000000000) != 0;
+        public bool Mrg => (_opcode & 0x2000000000) != 0;
+        public bool Psl => (_opcode & 0x1000000000) != 0;
+    }
+
+    struct InstXmadC
+    {
+        private ulong _opcode;
+        public InstXmadC(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool Mrg => (_opcode & 0x100000000000000) != 0;
+        public bool Psl => (_opcode & 0x80000000000000) != 0;
+        public bool X => (_opcode & 0x40000000000000) != 0;
+        public bool HiloA => (_opcode & 0x20000000000000) != 0;
+        public bool HiloB => (_opcode & 0x10000000000000) != 0;
+        public XmadCop2 XmadCop => (XmadCop2)((_opcode >> 50) & 0x3);
+        public bool BSigned => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+
+    struct InstXmadRc
+    {
+        private ulong _opcode;
+        public InstXmadRc(ulong opcode) => _opcode = opcode;
+        public int Dest => (int)((_opcode >> 0) & 0xFF);
+        public int SrcA => (int)((_opcode >> 8) & 0xFF);
+        public int SrcC => (int)((_opcode >> 39) & 0xFF);
+        public int CbufSlot => (int)((_opcode >> 34) & 0x1F);
+        public int CbufOffset => (int)((_opcode >> 20) & 0x3FFF);
+        public int Pred => (int)((_opcode >> 16) & 0x7);
+        public bool PredInv => (_opcode & 0x80000) != 0;
+        public bool WriteCC => (_opcode & 0x800000000000) != 0;
+        public bool X => (_opcode & 0x40000000000000) != 0;
+        public bool HiloA => (_opcode & 0x20000000000000) != 0;
+        public bool HiloB => (_opcode & 0x10000000000000) != 0;
+        public XmadCop2 XmadCop => (XmadCop2)((_opcode >> 50) & 0x3);
+        public bool BSigned => (_opcode & 0x2000000000000) != 0;
+        public bool ASigned => (_opcode & 0x1000000000000) != 0;
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/InstName.cs b/src/Ryujinx.Graphics.Shader/Decoders/InstName.cs
new file mode 100644
index 00000000..9c79b7a5
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/InstName.cs
@@ -0,0 +1,188 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    enum InstName : byte
+    {
+        Invalid = 0,
+
+        Al2p,
+        Ald,
+        Ast,
+        Atom,
+        AtomCas,
+        Atoms,
+        AtomsCas,
+        B2r,
+        Bar,
+        Bfe,
+        Bfi,
+        Bpt,
+        Bra,
+        Brk,
+        Brx,
+        Cal,
+        Cctl,
+        Cctll,
+        Cctlt,
+        Cont,
+        Cset,
+        Csetp,
+        Cs2r,
+        Dadd,
+        Depbar,
+        Dfma,
+        Dmnmx,
+        Dmul,
+        Dset,
+        Dsetp,
+        Exit,
+        F2f,
+        F2i,
+        Fadd,
+        Fadd32i,
+        Fchk,
+        Fcmp,
+        Ffma,
+        Ffma32i,
+        Flo,
+        Fmnmx,
+        Fmul,
+        Fmul32i,
+        Fset,
+        Fsetp,
+        Fswzadd,
+        Getcrsptr,
+        Getlmembase,
+        Hadd2,
+        Hadd232i,
+        Hfma2,
+        Hmul2,
+        Hmul232i,
+        Hset2,
+        Hsetp2,
+        I2f,
+        I2i,
+        Iadd,
+        Iadd32i,
+        Iadd3,
+        Icmp,
+        Ide,
+        Idp,
+        Imad,
+        Imad32i,
+        Imadsp,
+        Imnmx,
+        Imul,
+        Imul32i,
+        Ipa,
+        Isberd,
+        Iscadd,
+        Iscadd32i,
+        Iset,
+        Isetp,
+        Jcal,
+        Jmp,
+        Jmx,
+        Kil,
+        Ld,
+        Ldc,
+        Ldg,
+        Ldl,
+        Lds,
+        Lea,
+        LeaHi,
+        Lepc,
+        Longjmp,
+        Lop,
+        Lop3,
+        Lop32i,
+        Membar,
+        Mov,
+        Mov32i,
+        Mufu,
+        Nop,
+        Out,
+        P2r,
+        Pbk,
+        Pcnt,
+        Pexit,
+        Pixld,
+        Plongjmp,
+        Popc,
+        Pret,
+        Prmt,
+        Pset,
+        Psetp,
+        R2b,
+        R2p,
+        Ram,
+        Red,
+        Ret,
+        Rro,
+        Rtt,
+        S2r,
+        Sam,
+        Sel,
+        Setcrsptr,
+        Setlmembase,
+        Shf,
+        Shf_2,
+        Shf_3,
+        Shf_4,
+        Shfl,
+        Shl,
+        Shr,
+        Ssy,
+        St,
+        Stg,
+        Stl,
+        Stp,
+        Sts,
+        SuatomB,
+        Suatom,
+        SuatomB2,
+        SuatomCasB,
+        SuatomCas,
+        SuldDB,
+        SuldD,
+        SuldB,
+        Suld,
+        SuredB,
+        Sured,
+        SustDB,
+        SustD,
+        SustB,
+        Sust,
+        Sync,
+        Tex,
+        TexB,
+        Texs,
+        TexsF16,
+        Tld,
+        TldB,
+        Tlds,
+        TldsF16,
+        Tld4,
+        Tld4B,
+        Tld4s,
+        Tld4sF16,
+        Tmml,
+        TmmlB,
+        Txa,
+        Txd,
+        TxdB,
+        Txq,
+        TxqB,
+        Vabsdiff,
+        Vabsdiff4,
+        Vadd,
+        Vmad,
+        Vmnmx,
+        Vote,
+        Votevtg,
+        Vset,
+        Vsetp,
+        Vshl,
+        Vshr,
+        Xmad,
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/InstOp.cs b/src/Ryujinx.Graphics.Shader/Decoders/InstOp.cs
new file mode 100644
index 00000000..39244e64
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/InstOp.cs
@@ -0,0 +1,27 @@
+using Ryujinx.Graphics.Shader.Instructions;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    readonly struct InstOp
+    {
+        public readonly ulong Address;
+        public readonly ulong RawOpCode;
+        public readonly InstEmitter Emitter;
+        public readonly InstProps Props;
+        public readonly InstName Name;
+
+        public InstOp(ulong address, ulong rawOpCode, InstName name, InstEmitter emitter, InstProps props)
+        {
+            Address = address;
+            RawOpCode = rawOpCode;
+            Name = name;
+            Emitter = emitter;
+            Props = props;
+        }
+
+        public ulong GetAbsoluteAddress()
+        {
+            return (ulong)((long)Address + (((int)(RawOpCode >> 20) << 8) >> 8) + 8);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/InstProps.cs b/src/Ryujinx.Graphics.Shader/Decoders/InstProps.cs
new file mode 100644
index 00000000..1af94ab5
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/InstProps.cs
@@ -0,0 +1,28 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    enum InstProps : ushort
+    {
+        None = 0,
+        Rd = 1 << 0,
+        Rd2 = 1 << 1,
+        Ra = 1 << 2,
+        Rb = 1 << 3,
+        Rb2 = 1 << 4,
+        Ib = 1 << 5,
+        Rc = 1 << 6,
+
+        Pd = 1 << 7,
+        LPd = 2 << 7,
+        SPd = 3 << 7,
+        TPd = 4 << 7,
+        VPd = 5 << 7,
+        PdMask = 7 << 7,
+
+        Pdn = 1 << 10,
+        Ps = 1 << 11,
+        Tex = 1 << 12,
+        TexB = 1 << 13,
+        Bra = 1 << 14,
+        NoPred = 1 << 15
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/InstTable.cs b/src/Ryujinx.Graphics.Shader/Decoders/InstTable.cs
new file mode 100644
index 00000000..eaa77930
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/InstTable.cs
@@ -0,0 +1,390 @@
+using Ryujinx.Graphics.Shader.Instructions;
+using System;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    static class InstTable
+    {
+        private const int EncodingBits = 14;
+
+        private readonly struct TableEntry
+        {
+            public InstName Name { get; }
+            public InstEmitter Emitter { get; }
+            public InstProps Props { get; }
+
+            public int XBits { get; }
+
+            public TableEntry(InstName name, InstEmitter emitter, InstProps props, int xBits)
+            {
+                Name = name;
+                Emitter = emitter;
+                Props = props;
+                XBits = xBits;
+            }
+        }
+
+        private static TableEntry[] _opCodes;
+
+        static InstTable()
+        {
+            _opCodes = new TableEntry[1 << EncodingBits];
+
+            #region Instructions
+            Add("1110111110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Al2p,        InstEmit.Al2p,        InstProps.Rd  | InstProps.Ra);
+            Add("1110111111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ald,         InstEmit.Ald,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ast,         InstEmit.Ast,         InstProps.Ra  | InstProps.Rb2 | InstProps.Rc);
+            Add("11101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Atom,        InstEmit.Atom,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("111011101111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.AtomCas,     InstEmit.AtomCas,     InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("11101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Atoms,       InstEmit.Atoms,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("111011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.AtomsCas,    InstEmit.AtomsCas,    InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("1111000010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.B2r,         InstEmit.B2r,         InstProps.Rd  | InstProps.Ra  | InstProps.VPd);
+            Add("1111000010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bar,         InstEmit.Bar,         InstProps.Ra  | InstProps.Ps);
+            Add("0101110000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe,         InstEmit.BfeR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x00000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe,         InstEmit.BfeI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe,         InstEmit.BfeC,        InstProps.Rd  | InstProps.Ra);
+            Add("0101101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi,         InstEmit.BfiR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x11110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi,         InstEmit.BfiI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("0100101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi,         InstEmit.BfiC,        InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("0101001111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi,         InstEmit.BfiRc,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("111000111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bpt,         InstEmit.Bpt,         InstProps.NoPred);
+            Add("111000100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bra,         InstEmit.Bra,         InstProps.Bra);
+            Add("111000110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Brk,         InstEmit.Brk,         InstProps.Bra);
+            Add("111000100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Brx,         InstEmit.Brx,         InstProps.Ra  | InstProps.Bra);
+            Add("111000100110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cal,         InstEmit.Cal,         InstProps.Bra | InstProps.NoPred);
+            Add("11101111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctl,        InstEmit.Cctl,        InstProps.Ra);
+            Add("1110111110000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctll,       InstEmit.Cctll,       InstProps.Ra);
+            Add("1110101111110xx0000000000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctlt,       InstEmit.Cctlt);
+            Add("1110101111101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctlt,       InstEmit.Cctlt,       InstProps.Rc);
+            Add("111000110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cont,        InstEmit.Cont,        InstProps.Bra);
+            Add("0101000010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cset,        InstEmit.Cset,        InstProps.Rd  | InstProps.Ps);
+            Add("0101000010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Csetp,       InstEmit.Csetp,       InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0101000011001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cs2r,        InstEmit.Cs2r,        InstProps.Rd);
+            Add("0101110001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd,        InstEmit.DaddR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x01110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd,        InstEmit.DaddI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd,        InstEmit.DaddC,       InstProps.Rd  | InstProps.Ra);
+            Add("1111000011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Depbar,      InstEmit.Depbar);
+            Add("010110110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma,        InstEmit.DfmaR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x0111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma,        InstEmit.DfmaI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma,        InstEmit.DfmaC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma,        InstEmit.DfmaRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("0101110001010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx,       InstEmit.DmnmxR,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011100x01010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx,       InstEmit.DmnmxI,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("0100110001010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx,       InstEmit.DmnmxC,      InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("0101110010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul,        InstEmit.DmulR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x10000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul,        InstEmit.DmulI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul,        InstEmit.DmulC,       InstProps.Rd  | InstProps.Ra);
+            Add("010110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset,        InstEmit.DsetR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011001x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset,        InstEmit.DsetI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("010010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset,        InstEmit.DsetC,       InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("010110111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp,       InstEmit.DsetpR,      InstProps.Ra  | InstProps.Rb  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0011011x1000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp,       InstEmit.DsetpI,      InstProps.Ra  | InstProps.Ib  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("010010111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp,       InstEmit.DsetpC,      InstProps.Ra  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("111000110000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Exit,        InstEmit.Exit,        InstProps.Bra);
+            Add("0101110010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f,         InstEmit.F2fR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x10101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f,         InstEmit.F2fI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f,         InstEmit.F2fC,        InstProps.Rd);
+            Add("0101110010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i,         InstEmit.F2iR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x10110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i,         InstEmit.F2iI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i,         InstEmit.F2iC,        InstProps.Rd);
+            Add("0101110001011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd,        InstEmit.FaddR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x01011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd,        InstEmit.FaddI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110001011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd,        InstEmit.FaddC,       InstProps.Rd  | InstProps.Ra);
+            Add("000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd32i,     InstEmit.Fadd32i,     InstProps.Rd  | InstProps.Ra);
+            Add("0101110010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk,        InstEmit.FchkR,       InstProps.Ra  | InstProps.Rb  | InstProps.Pd);
+            Add("0011100x10001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk,        InstEmit.FchkI,       InstProps.Ra  | InstProps.Ib  | InstProps.Pd);
+            Add("0100110010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk,        InstEmit.FchkC,       InstProps.Ra  | InstProps.Pd);
+            Add("010110111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp,        InstEmit.FcmpR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x1010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp,        InstEmit.FcmpI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp,        InstEmit.FcmpC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp,        InstEmit.FcmpRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma,        InstEmit.FfmaR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011001x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma,        InstEmit.FfmaI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma,        InstEmit.FfmaC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma,        InstEmit.FfmaRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma32i,     InstEmit.Ffma32i,     InstProps.Rd  | InstProps.Ra);
+            Add("0101110000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo,         InstEmit.FloR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x00110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo,         InstEmit.FloI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo,         InstEmit.FloC,        InstProps.Rd);
+            Add("0101110001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx,       InstEmit.FmnmxR,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011100x01100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx,       InstEmit.FmnmxI,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("0100110001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx,       InstEmit.FmnmxC,      InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("0101110001101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul,        InstEmit.FmulR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x01101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul,        InstEmit.FmulI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110001101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul,        InstEmit.FmulC,       InstProps.Rd  | InstProps.Ra);
+            Add("00011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul32i,     InstEmit.Fmul32i,     InstProps.Rd  | InstProps.Ra);
+            Add("01011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset,        InstEmit.FsetR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset,        InstEmit.FsetI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("01001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset,        InstEmit.FsetC,       InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("010110111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp,       InstEmit.FsetpR,      InstProps.Ra  | InstProps.Rb  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0011011x1011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp,       InstEmit.FsetpI,      InstProps.Ra  | InstProps.Ib  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("010010111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp,       InstEmit.FsetpC,      InstProps.Ra  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0101000011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fswzadd,     InstEmit.Fswzadd,     InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("111000101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Getcrsptr,   InstEmit.Getcrsptr,   InstProps.Rd  | InstProps.NoPred);
+            Add("111000101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Getlmembase, InstEmit.Getlmembase, InstProps.Rd  | InstProps.NoPred);
+            Add("0101110100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2,       InstEmit.Hadd2R,      InstProps.Rd  | InstProps.Ra);
+            Add("0111101x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2,       InstEmit.Hadd2I,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0111101x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2,       InstEmit.Hadd2C,      InstProps.Rd  | InstProps.Ra);
+            Add("0010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd232i,    InstEmit.Hadd232i,    InstProps.Rd  | InstProps.Ra);
+            Add("0101110100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2,       InstEmit.Hfma2R,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("01110xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2,       InstEmit.Hfma2I,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("01110xxx1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2,       InstEmit.Hfma2C,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("01100xxx1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2,       InstEmit.Hfma2Rc,     InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("0010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2,       InstEmit.Hfma232i,    InstProps.Rd  | InstProps.Ra);
+            Add("0101110100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2,       InstEmit.Hmul2R,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0111100x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2,       InstEmit.Hmul2I,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0111100x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2,       InstEmit.Hmul2C,      InstProps.Rd  | InstProps.Ra);
+            Add("0010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul232i,    InstEmit.Hmul232i,    InstProps.Rd  | InstProps.Ra);
+            Add("0101110100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2,       InstEmit.Hset2R,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0111110x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2,       InstEmit.Hset2I,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("0111110x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2,       InstEmit.Hset2C,      InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("0101110100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2,      InstEmit.Hsetp2R,     InstProps.Ra  | InstProps.Rb  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0111111x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2,      InstEmit.Hsetp2I,     InstProps.Ra  | InstProps.Ib  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0111111x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2,      InstEmit.Hsetp2C,     InstProps.Ra  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0101110010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f,         InstEmit.I2fR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x10111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f,         InstEmit.I2fI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f,         InstEmit.I2fC,        InstProps.Rd);
+            Add("0101110011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i,         InstEmit.I2iR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x11100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i,         InstEmit.I2iI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i,         InstEmit.I2iC,        InstProps.Rd);
+            Add("0101110000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd,        InstEmit.IaddR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x00010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd,        InstEmit.IaddI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd,        InstEmit.IaddC,       InstProps.Rd  | InstProps.Ra);
+            Add("0001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd32i,     InstEmit.Iadd32i,     InstProps.Rd  | InstProps.Ra);
+            Add("010111001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3,       InstEmit.Iadd3R,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011100x1100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3,       InstEmit.Iadd3I,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010011001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3,       InstEmit.Iadd3C,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010110110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp,        InstEmit.IcmpR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x0100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp,        InstEmit.IcmpI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp,        InstEmit.IcmpC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp,        InstEmit.IcmpRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("111000111001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ide,         InstEmit.Ide,         InstProps.NoPred);
+            Add("0101001111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Idp,         InstEmit.IdpR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0101001111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Idp,         InstEmit.IdpC,        InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad,        InstEmit.ImadR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011010x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad,        InstEmit.ImadI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad,        InstEmit.ImadC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad,        InstEmit.ImadRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad32i,     InstEmit.Imad32i,     InstProps.Rd  | InstProps.Ra);
+            Add("010110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp,      InstEmit.ImadspR,     InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011010x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp,      InstEmit.ImadspI,     InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp,      InstEmit.ImadspC,     InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp,      InstEmit.ImadspRc,    InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("0101110000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx,       InstEmit.ImnmxR,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011100x00100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx,       InstEmit.ImnmxI,      InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("0100110000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx,       InstEmit.ImnmxC,      InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("0101110000111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul,        InstEmit.ImulR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x00111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul,        InstEmit.ImulI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110000111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul,        InstEmit.ImulC,       InstProps.Rd  | InstProps.Ra);
+            Add("00011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul32i,     InstEmit.Imul32i,     InstProps.Rd  | InstProps.Ra);
+            Add("11100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ipa,         InstEmit.Ipa,         InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("1110111111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isberd,      InstEmit.Isberd,      InstProps.Rd  | InstProps.Ra);
+            Add("0101110000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd,      InstEmit.IscaddR,     InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x00011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd,      InstEmit.IscaddI,     InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd,      InstEmit.IscaddC,     InstProps.Rd  | InstProps.Ra);
+            Add("000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd32i,   InstEmit.Iscadd32i,   InstProps.Rd  | InstProps.Ra);
+            Add("010110110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset,        InstEmit.IsetR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011011x0101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset,        InstEmit.IsetI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("010010110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset,        InstEmit.IsetC,       InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("010110110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp,       InstEmit.IsetpR,      InstProps.Ra  | InstProps.Rb  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("0011011x0110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp,       InstEmit.IsetpI,      InstProps.Ra  | InstProps.Ib  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("010010110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp,       InstEmit.IsetpC,      InstProps.Ra  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("111000100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jcal,        InstEmit.Jcal,        InstProps.Bra);
+            Add("111000100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jmp,         InstEmit.Jmp,         InstProps.Ra  | InstProps.Bra);
+            Add("111000100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jmx,         InstEmit.Jmx,         InstProps.Ra  | InstProps.Bra);
+            Add("111000110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Kil,         InstEmit.Kil,         InstProps.Bra);
+            Add("100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ld,          InstEmit.Ld,          InstProps.Rd  | InstProps.Ra);
+            Add("1110111110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldc,         InstEmit.Ldc,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldg,         InstEmit.Ldg,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldl,         InstEmit.Ldl,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lds,         InstEmit.Lds,         InstProps.Rd  | InstProps.Ra);
+            Add("0101101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea,         InstEmit.LeaR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.LPd);
+            Add("0011011x11010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea,         InstEmit.LeaI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.LPd);
+            Add("0100101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea,         InstEmit.LeaC,        InstProps.Rd  | InstProps.Ra  | InstProps.LPd);
+            Add("0101101111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.LeaHi,       InstEmit.LeaHiR,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc  | InstProps.LPd);
+            Add("000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.LeaHi,       InstEmit.LeaHiC,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc  | InstProps.LPd);
+            Add("0101000011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lepc,        InstEmit.Lepc);
+            Add("111000110001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Longjmp,     InstEmit.Longjmp,     InstProps.Bra);
+            Add("0101110001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop,         InstEmit.LopR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.LPd);
+            Add("0011100x01000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop,         InstEmit.LopI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.LPd);
+            Add("0100110001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop,         InstEmit.LopC,        InstProps.Rd  | InstProps.Ra  | InstProps.LPd);
+            Add("0101101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3,        InstEmit.Lop3R,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc  | InstProps.LPd);
+            Add("001111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3,        InstEmit.Lop3I,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("0000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3,        InstEmit.Lop3C,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop32i,      InstEmit.Lop32i,      InstProps.Rd  | InstProps.Ra);
+            Add("1110111110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Membar,      InstEmit.Membar);
+            Add("0101110010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov,         InstEmit.MovR,        InstProps.Rd  | InstProps.Ra);
+            Add("0011100x10011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov,         InstEmit.MovI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov,         InstEmit.MovC,        InstProps.Rd);
+            Add("000000010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov32i,      InstEmit.Mov32i,      InstProps.Rd);
+            Add("0101000010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mufu,        InstEmit.Mufu,        InstProps.Rd  | InstProps.Ra);
+            Add("0101000010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Nop,         InstEmit.Nop);
+            Add("1111101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out,         InstEmit.OutR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("1111011x11100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out,         InstEmit.OutI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("1110101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out,         InstEmit.OutC,        InstProps.Rd  | InstProps.Ra);
+            Add("0101110011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r,         InstEmit.P2rR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x11101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r,         InstEmit.P2rI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r,         InstEmit.P2rC,        InstProps.Rd  | InstProps.Ra);
+            Add("111000101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pbk,         InstEmit.Pbk,         InstProps.NoPred);
+            Add("111000101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pcnt,        InstEmit.Pcnt,        InstProps.NoPred);
+            Add("111000100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pexit,       InstEmit.Pexit);
+            Add("1110111111101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pixld,       InstEmit.Pixld,       InstProps.Rd  | InstProps.Ra  | InstProps.VPd);
+            Add("111000101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Plongjmp,    InstEmit.Plongjmp,    InstProps.Bra | InstProps.NoPred);
+            Add("0101110000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc,        InstEmit.PopcR,       InstProps.Rd  | InstProps.Rb);
+            Add("0011100x00001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc,        InstEmit.PopcI,       InstProps.Rd  | InstProps.Ib);
+            Add("0100110000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc,        InstEmit.PopcC,       InstProps.Rd);
+            Add("111000100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pret,        InstEmit.Pret,        InstProps.NoPred);
+            Add("010110111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt,        InstEmit.PrmtR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x1100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt,        InstEmit.PrmtI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("010010111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt,        InstEmit.PrmtC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt,        InstEmit.PrmtRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("0101000010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pset,        InstEmit.Pset,        InstProps.Rd  | InstProps.Ps);
+            Add("0101000010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Psetp,       InstEmit.Psetp,       InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("1111000011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2b,         InstEmit.R2b,         InstProps.Rb);
+            Add("0101110011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p,         InstEmit.R2pR,        InstProps.Ra  | InstProps.Rb);
+            Add("0011100x11110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p,         InstEmit.R2pI,        InstProps.Ra  | InstProps.Ib);
+            Add("0100110011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p,         InstEmit.R2pC,        InstProps.Ra);
+            Add("111000111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ram,         InstEmit.Ram,         InstProps.NoPred);
+            Add("1110101111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Red,         InstEmit.Red,         InstProps.Ra  | InstProps.Rb2);
+            Add("111000110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ret,         InstEmit.Ret,         InstProps.Bra);
+            Add("0101110010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro,         InstEmit.RroR,        InstProps.Rd  | InstProps.Rb);
+            Add("0011100x10010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro,         InstEmit.RroI,        InstProps.Rd  | InstProps.Ib);
+            Add("0100110010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro,         InstEmit.RroC,        InstProps.Rd);
+            Add("111000110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rtt,         InstEmit.Rtt,         InstProps.NoPred);
+            Add("1111000011001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.S2r,         InstEmit.S2r,         InstProps.Rd);
+            Add("111000110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sam,         InstEmit.Sam,         InstProps.NoPred);
+            Add("0101110010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel,         InstEmit.SelR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Ps);
+            Add("0011100x10100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel,         InstEmit.SelI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Ps);
+            Add("0100110010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel,         InstEmit.SelC,        InstProps.Rd  | InstProps.Ra  | InstProps.Ps);
+            Add("111000101110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Setcrsptr,   InstEmit.Setcrsptr,   InstProps.Ra  | InstProps.NoPred);
+            Add("111000101111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Setlmembase, InstEmit.Setlmembase, InstProps.Ra  | InstProps.NoPred);
+            Add("0101101111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf,         InstEmit.ShfLR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0101110011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf,         InstEmit.ShfRR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf,         InstEmit.ShfLI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("0011100x11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf,         InstEmit.ShfRI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("1110111100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shfl,        InstEmit.Shfl,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc  | InstProps.LPd);
+            Add("0101110001001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl,         InstEmit.ShlR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x01001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl,         InstEmit.ShlI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110001001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl,         InstEmit.ShlC,        InstProps.Rd  | InstProps.Ra);
+            Add("0101110000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr,         InstEmit.ShrR,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("0011100x00101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr,         InstEmit.ShrI,        InstProps.Rd  | InstProps.Ra  | InstProps.Ib);
+            Add("0100110000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr,         InstEmit.ShrC,        InstProps.Rd  | InstProps.Ra);
+            Add("111000101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ssy,         InstEmit.Ssy,         InstProps.NoPred);
+            Add("101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.St,          InstEmit.St,          InstProps.Rd  | InstProps.Ra);
+            Add("1110111011011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stg,         InstEmit.Stg,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stl,         InstEmit.Stl,         InstProps.Rd  | InstProps.Ra);
+            Add("1110111010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stp,         InstEmit.Stp,         InstProps.NoPred);
+            Add("1110111101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sts,         InstEmit.Sts,         InstProps.Rd  | InstProps.Ra);
+            Add("1110101001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomB,     InstEmit.SuatomB,     InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("11101010x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Suatom,      InstEmit.Suatom,      InstProps.Rd  | InstProps.Ra  | InstProps.Rb);
+            Add("1110101110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomB2,    InstEmit.SuatomB2,    InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("1110101011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomCasB,  InstEmit.SuatomCasB,  InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc  | InstProps.SPd);
+            Add("1110101x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomCas,   InstEmit.SuatomCas,   InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.SPd);
+            Add("1110101100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldDB,      InstEmit.SuldDB,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc  | InstProps.SPd | InstProps.TexB);
+            Add("1110101100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldD,       InstEmit.SuldD,       InstProps.Rd  | InstProps.Ra  | InstProps.SPd | InstProps.Tex);
+            Add("1110101100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldB,       InstEmit.SuldB,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc  | InstProps.SPd | InstProps.TexB);
+            Add("1110101100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Suld,        InstEmit.Suld,        InstProps.Rd  | InstProps.Ra  | InstProps.SPd | InstProps.Tex);
+            Add("1110101101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuredB,      InstEmit.SuredB,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("1110101101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sured,       InstEmit.Sured,       InstProps.Rd  | InstProps.Ra);
+            Add("1110101100110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustDB,      InstEmit.SustDB,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc  | InstProps.TexB);
+            Add("1110101100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustD,       InstEmit.SustD,       InstProps.Rd  | InstProps.Ra  | InstProps.Tex);
+            Add("1110101100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustB,       InstEmit.SustB,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc  | InstProps.TexB);
+            Add("1110101100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sust,        InstEmit.Sust,        InstProps.Rd  | InstProps.Ra  | InstProps.Tex);
+            Add("1111000011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sync,        InstEmit.Sync,        InstProps.Bra);
+            Add("11000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tex,         InstEmit.Tex,         InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.Tex);
+            Add("1101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TexB,        InstEmit.TexB,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.TexB);
+            Add("1101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Texs,        InstEmit.Texs,        InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("1101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TexsF16,     InstEmit.TexsF16,     InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("11011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld,         InstEmit.Tld,         InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.Tex);
+            Add("11011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TldB,        InstEmit.TldB,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.TexB);
+            Add("1101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tlds,        InstEmit.Tlds,        InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("1101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TldsF16,     InstEmit.TldsF16,     InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4,        InstEmit.Tld4,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.Tex);
+            Add("1101111011xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4B,       InstEmit.Tld4B,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.TexB);
+            Add("1101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4s,       InstEmit.Tld4s,       InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("1101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4sF16,    InstEmit.Tld4sF16,    InstProps.Rd  | InstProps.Rd2 | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("1101111101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tmml,        InstEmit.Tmml,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Tex);
+            Add("1101111101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TmmlB,       InstEmit.TmmlB,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TexB);
+            Add("1101111101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txa,         InstEmit.Txa,         InstProps.Rd  | InstProps.Ra  | InstProps.Tex);
+            Add("110111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txd,         InstEmit.Txd,         InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.Tex);
+            Add("1101111001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TxdB,        InstEmit.TxdB,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.TPd | InstProps.TexB);
+            Add("1101111101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txq,         InstEmit.Txq,         InstProps.Rd  | InstProps.Ra  | InstProps.Tex);
+            Add("1101111101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TxqB,        InstEmit.TxqB,        InstProps.Rd  | InstProps.Ra  | InstProps.TexB);
+            Add("01010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vabsdiff,    InstEmit.Vabsdiff,    InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("010100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vabsdiff4,   InstEmit.Vabsdiff4,   InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vadd,        InstEmit.Vadd,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("01011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vmad,        InstEmit.Vmad,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vmnmx,       InstEmit.Vmnmx,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0101000011011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vote,        InstEmit.Vote,        InstProps.Rd  | InstProps.VPd | InstProps.Ps);
+            Add("0101000011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Votevtg,     InstEmit.Votevtg);
+            Add("0100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vset,        InstEmit.Vset,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0101000011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vsetp,       InstEmit.Vsetp,       InstProps.Ra  | InstProps.Rb  | InstProps.Pd  | InstProps.Pdn | InstProps.Ps);
+            Add("01010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vshl,        InstEmit.Vshl,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("01010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vshr,        InstEmit.Vshr,        InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0101101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad,        InstEmit.XmadR,       InstProps.Rd  | InstProps.Ra  | InstProps.Rb  | InstProps.Rc);
+            Add("0011011x00xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad,        InstEmit.XmadI,       InstProps.Rd  | InstProps.Ra  | InstProps.Ib  | InstProps.Rc);
+            Add("0100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad,        InstEmit.XmadC,       InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            Add("010100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad,        InstEmit.XmadRc,      InstProps.Rd  | InstProps.Ra  | InstProps.Rc);
+            #endregion
+        }
+
+        private static void Add(string encoding, InstName name, InstEmitter emitter, InstProps props = InstProps.None)
+        {
+            ReadOnlySpan<char> encodingPart = encoding.AsSpan(0, EncodingBits);
+
+            int bit = encodingPart.Length - 1;
+            int value = 0;
+            int xMask = 0;
+            int xBits = 0;
+
+            int[] xPos = new int[encodingPart.Length];
+
+            for (int index = 0; index < encodingPart.Length; index++, bit--)
+            {
+                char chr = encodingPart[index];
+
+                if (chr == '1')
+                {
+                    value |= 1 << bit;
+                }
+                else if (chr == 'x')
+                {
+                    xMask |= 1 << bit;
+
+                    xPos[xBits++] = bit;
+                }
+            }
+
+            xMask = ~xMask;
+
+            TableEntry entry = new TableEntry(name, emitter, props, xBits);
+
+            for (int index = 0; index < (1 << xBits); index++)
+            {
+                value &= xMask;
+
+                for (int x = 0; x < xBits; x++)
+                {
+                    value |= ((index >> x) & 1) << xPos[x];
+                }
+
+                if (_opCodes[value].Emitter == null || _opCodes[value].XBits > xBits)
+                {
+                    _opCodes[value] = entry;
+                }
+            }
+        }
+
+        public static InstOp GetOp(ulong address, ulong opCode)
+        {
+            ref TableEntry entry = ref _opCodes[opCode >> (64 - EncodingBits)];
+
+            if (entry.Emitter != null)
+            {
+                return new InstOp(address, opCode, entry.Name, entry.Emitter, entry.Props);
+            }
+
+            return new InstOp(address, opCode, InstName.Invalid, null, InstProps.None);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/Register.cs b/src/Ryujinx.Graphics.Shader/Decoders/Register.cs
new file mode 100644
index 00000000..e375096d
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/Register.cs
@@ -0,0 +1,36 @@
+using System;
+
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    readonly struct Register : IEquatable<Register>
+    {
+        public int Index { get; }
+
+        public RegisterType Type { get; }
+
+        public bool IsRZ => Type == RegisterType.Gpr       && Index == RegisterConsts.RegisterZeroIndex;
+        public bool IsPT => Type == RegisterType.Predicate && Index == RegisterConsts.PredicateTrueIndex;
+
+        public Register(int index, RegisterType type)
+        {
+            Index = index;
+            Type  = type;
+        }
+
+        public override int GetHashCode()
+        {
+            return (ushort)Index | ((ushort)Type << 16);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is Register reg && Equals(reg);
+        }
+
+        public bool Equals(Register other)
+        {
+            return other.Index == Index &&
+                   other.Type  == Type;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/RegisterConsts.cs b/src/Ryujinx.Graphics.Shader/Decoders/RegisterConsts.cs
new file mode 100644
index 00000000..d381f954
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/RegisterConsts.cs
@@ -0,0 +1,13 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    static class RegisterConsts
+    {
+        public const int GprsCount  = 255;
+        public const int PredsCount = 7;
+        public const int FlagsCount = 4;
+        public const int TotalCount = GprsCount + PredsCount + FlagsCount;
+
+        public const int RegisterZeroIndex  = GprsCount;
+        public const int PredicateTrueIndex = PredsCount;
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Graphics.Shader/Decoders/RegisterType.cs b/src/Ryujinx.Graphics.Shader/Decoders/RegisterType.cs
new file mode 100644
index 00000000..648f816a
--- /dev/null
+++ b/src/Ryujinx.Graphics.Shader/Decoders/RegisterType.cs
@@ -0,0 +1,9 @@
+namespace Ryujinx.Graphics.Shader.Decoders
+{
+    enum RegisterType
+    {
+        Flag,
+        Gpr,
+        Predicate,
+    }
+}
\ No newline at end of file