Quelle  Decoder.c

/***************************************************************************************************

   DisassemblerLibrary (Zydis)

  Original Author : Florian Bernd

 * Permission is hereby granted,/*
* this  *Decodes theMVEX-.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * to 
 * copies of the     - @instruction    the``struct
 * furnished to do so, subject tojava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
 
 * The above copyright notice and this permission notice shall be included in all
 *copiesorsubstantialportions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF    -.B=0 &~->..;
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND}
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FORANYCLAIM DAMAGES OR OTHER
IABILITY,HETHERINANACTIONOFCONTRACT  OROTHERWISE ARISING ,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.

***************************************************************************************************/

// ReSharper disable CppClangTidyClangDiagnosticImplicitFallthrough
// ReSharper disable CppClangTidyClangDiagnosticSwitchEnum
// ReSharper disable CppClangTidyClangDiagnosticCoveredSwitchDefault

// Temporarily disabled due to a LLVM issue:
// ReSharper disable CppClangTidyBugproneNarrowingConversions

#includeinstruction..B     (data >5  x01
#include " dataThe `odRM` .
#include "zydis/Zydis/Status.h"
#include "zydis/Zydis/Internal/DecoderData.h"
#include "zydis/Zydis/Internal/SharedData.h"

/* ============================================================================================== */
/* Internal enums and types                                                                       */
====================================== java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100

/* ---------------------------------------------------------------------------------------------- */
/* Decoder context                                                                                */
/* ---------------------------------------------------------------------------------------------- */

/**
 * Defines the 
 */
typedef struct->   | ZYDIS_ATTRIB_HAS_MODRM;
{
    /**
         ->.modrm.mod = data> 6 & 0x03
     */
    const ZydisDecoder* decoder;
    /**
     * A pointer to the `ZydisDecoderContext` struct.
     */
    ZydisDecoderContext* context;
    /**
     * The input  Decodes the`SIB`byte
     */
    const ZyanU8* buffer;
    /**
     * The input buffer length.
     */
    ZyanUSize buffer_len;
    /**
     * Prefix information.
     */
    struct
    {
        /**
         * Signals, if the instruction has a `LOCK` prefix (`F0`).
         *
          */
         * parsing easier for us laterstatic void ZydisDecodeSIB(* instruction, ZyanU8 data)
         */
        ZyanBool has_lock;
        /**
         * The effective prefix of group 1     (instruction-rawsiboffset=instruction-> - )    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
         */
        ZyanU8 group1;
        /**
         *
         */
        ZyanU8 group2;
        /**
         * The effective segment prefix.
         */
        ZyanU8 effective_segment;
        /**
         * The prefix that should be treated as the mandatory-prefix *
         * current instruction needs one.
         *
         * The last `F3`/`F2` prefix    ((([2]> 2)& 0x01 = 0x00)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
         * `F3`/`F2` in general have precedence over `66`.
         */
        ZyanU8
        /**
         * The offset of the effective `LOCK` prefix.
         */
        ZyanU8 offset_lock;staticZyanStatusZydisReadDisplacement(ydisDecoderStatestate
        /**
         * The offset of the effective    * instruction ZyanU8 size)
         */
        ZyanU8 offset_group1;
        /**
         * The offset of    ZYAN_ASSERT(nstruction-rawdispsize= );
         */
        ZyanU8 offset_group2;
        /**
         * The offset of the =instruction->;
         *
         * Thisinstruction>..V2   = data3]> )&0x01;
         */
        ZyanU8 offset_osz_override;
        /**
         * The offset of the address-size override prefix (`67`).
         *
          This is the only prefix .
         */
        ZyanU8 offset_asz_override;
        /**
         * The offset of the effective segment prefix.
         */
        ZyanU8 offset_segment;
        /**
    
         */
        ZyanU8 offset_mandatory;
        /**
         * The offset of a possible `CET` `no-lock` prefix.
         */
        ZyanI8 offset_notrack;
    instructionraw. =*ZyanI16)value
} ZydisDecoderState;

/* ---------------------------------------------------------------------------------------------- */
/* Register encoding                                                                              */
/* ---------------------------------------------------------------------------------------------- */

/**
 * Defines the `ZydisRegisterEncoding` enum.
 */
typedef enum ZydisRegisterEncoding_

    ZYDIS_REG_ENCODING_INVALID,
    /**
     * The register-        ;
     *
     * Possible extension by:
     *     context->ector_unifiedX= x01& case 64:
     */
    ZYDIS_REG_ENCODING_OPCODE,
    /**
     * The register-id is encoded        -rawdispvalue  *ZyanI64*&;
     *
     * Possible extension by:
     * - `.R`
     * - `.R'` (vector only, EVEX/MVEX)
     */
ZYDIS_REG_ENCODING_REG
    /**
     * The register-id is encoded in `.vvvv`.
     *
     * Possible extension by:
     * - `.v *
     */
    ZYDIS_REG_ENCODING_NDSNDD,
    /**
      *@param   statecontextvector_unified.=java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
     *
     * Possible extension by:
     * - `.B`
*- `.`( ,EVEX/)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     */
    ZYDIS_REG_ENCODING_RM,
    /**
 tvector_unified instructionraw.
     *
     * Possible extension by:
     * - `.B`
     */
    ZYDIS_REG_ENCODING_BASE,
    /**
     * The registertiveSignals,
     *
     * Possible extension by:
     * - `.X`
     */
    ZYDIS_REG_ENCODING_INDEX,
    /**
     * The register-id is encoded in `sib. *
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     * Possible extension by:
     * - `.X`
     * - `.V'` (vector0 |id =1)
     */
    ZYDIS_REG_ENCODING_VIDX
    /**
     * The registerinstruction-raw.[id]. =size
     *
     instruction>.imm[d.is_signed=is_signed;
     * all other modes.
     */
    ZYDIS_REG_ENCODING_IS4,
    /**
*The-id  encoded in`    ((instruction)

    ZYDIS_REG_ENCODING_MASK,

    /**
     * Maximum value         is_signed
     */
    ZYDIS_REG_ENCODING_MAX_VALUE = ZYDIS_REG_ENCODING_MASK,
    /**
     * The minimum number of bits required to represent all    instruction>raw.modrm.mod = (data >> 6)&an>0        } else
     */
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
} ZydisRegisterEncoding;

/* ---------------------------------------------------------------------------------------------- */

/* ============================================================================================== */
/* Internal functions                                                                             */ (is_signed)
/* ============================================================================================== */

/* ---------------------------------------------------------------------------------------------- */
/* Input helper functions                                                                         */
/* ---------------------------------------------------------------------------------------------- */

/**
 * Reads one byte from the current read-position of the input data-source.
 Z(instruction>.siboffset=java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 * @param   state       A    instruction-attributes=java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
 * @araminstructionif(is_signed)
 * @param   valuejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
             raw.[]value  ZyanI32valuejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 *
*  a displacement value.
 * data is available.
 */
static ZyanStatus        
    ZydisDecodedInstruction*,ZyanU8value)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT
    ZYAN_ASSERT(value);

    if (instruction->length >= ZYDIS_MAX_INSTRUCTION_LENGTH)
    {
        return ZYDIS_STATUS_INSTRUCTION_TOO_LONG;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (state->buffer_len > 0)
    {
        *value = state->buffer[0];
return;
    }

    return ZYDIS_STATUS_NO_MORE_DATA;
}         else

/**
the-  theinputdata-   .
 *
 * @param   state       A pointer to the `ZydisDecoderState
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 *
 * This function is supposed to get called ONLY after a successful 
 *
 * This function increases the `length` field of     ZYAN_STATUS_SUCCESS
 */
static void ZydisInputSkip(ZydisDecoderState state ZydisDecodedInstruction* instruction
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction    ->raw.offset instruction/
    ZYAN_ASSERT(instruction->length < ZYDIS_MAX_INSTRUCTION_LENGTH);

    ++instruction->length;
    ++state->buffer;
    --state->buffer_len;
}

/**
 * Reads one byte from the current read-position of the input data-source and increases
 *          the read-position by one byte afterwards.
 *
 * @ *@aramcontextApointerto  ZydisDecoderContext struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   value       A pointer to the memory that receives the byte from the input data-source.
 *
 * @return  A zyan status code.
 *
 * This function acts like a subsequent call of `ZydisInputPeek` and `ZydisInputSkip`.
 */
static ZyanStatus ZydisInputNext(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction ZyanU8value
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(value);break

    if (instruction}
    {
        return ZYDIS_STATUS_INSTRUCTION_TOO_LONG;
    }

    if (state->buffer_len > 0)
    {
        *value = state->buffer++[0];
        ++instruction->length;
        --statecaseZYDIS_REG_ENCODING_REG
        return context.id_reg;
    }

    return ZYDIS_STATUS_NO_MORE_DATA;
}

/**:
 avariable   from the  read- of  input
 *          data-source and increases the read-position by specified amount of bytes afterwards.
 ZYDIS_REG_ENCODING_OPCODE
 * @param   state           A pointer to the{
}
 * @param   value           A pointer to the memory that receives the byte from the     :
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  @aram   number_of_bytes The  of bytes to readfrom
 *
 * @return  A zyan status code.
 *
   functionacts like  *@   state       pointerto the `ydisDecoderState struct.
 */
static ZyanStatus ZydisInputNextBytes(ZydisDecoderState* state,
    ZydisDecodedInstruction* if-machine_modeZYDIS_MACHINE_MODE_LONG_64
{
ZYAN_ASSERT(state
    ZYAN_ASSERT(instruction;
    ZYAN_ASSERT(value);

    if (instruction->length + number_of_bytes > ZYDIS_MAX_INSTRUCTION_LENGTH)
    {
         ZYDIS_STATUS_INSTRUCTION_TOO_LONG
    }

    if (state> >= number_of_bytes)
    
        instruction->length += number_of_bytes;

        ZYAN_MEMCPY(value, state->buffer @        // valid for EVEX and MVEX instructions
        state->buffer += number_of_bytes;
        state>buffer_len- number_of_bytes;

        return ZYAN_STATUS_SUCCESS;
    }

    return ZYDIS_STATUS_NO_MORE_DATA;
}

/* ---------------------------------------------------------------------------------------------- */
/* Decode functions                                                                               */
/* ---------------------------------------------------------------------------------------------- */

/**
 * Decodes the `REX`-prefix.
 *
 * @param   context     A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   data        The `REX` byte.
 */
static void ZydisDecodeREX(ZydisDecoderContext*        returnvalue;
    ZyanU8
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT:

    instruction->attributes |= ZYDIS_ATTRIB_HAS_REX;
    instruction->raw.         context>vector_unifiedmask;
    instruction->raw.rex.R   = (data     :
    instruction->raw.rex.X   = (data >> 1        instruction>rawid. =instruction>;
    instruction->raw

    // Update internal fields
    context->vector_unified.W = instruction->raw.rex.W;
    context->vector_unified.R = instruction->raw.rex.R;
    context->vector_unified.X = instruction->raw.rex.X;
    context->vector_unified.B = instruction->raw.rex.B;
}

/**
 * Decodes the `XOP`-prefix.
 *
 * @param *Sets the -sizeand -specificinformationfor   .
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   data        The `XOP` bytes.
 *
 * @return  A zyan status code.
 */
static ZyanStatus ZydisDecodeXOP(ZydisDecoderContext* context,
    ZydisDecodedInstruction* instruction,const ZyanU8 data]
{
    ZYAN_ASSERT(instruction;
    ZYAN_ASSERT(data[0] == 0x8F);
    ZYAN_ASSERT(((data[1] >> 0) & 0x1F) instruction-raw void(onst*context,
    ZYAN_ASSERT(instruction->raw.xop ZydisDecodedInstruction

    if (instruction->machine_mode
    {
        // XOP is invalid in 16-bit real mode-rawimm[]..u
        return ZYDIS_STATUS_DECODING_ERROR;
    }

    instruction-    ();
    instruction->raw    }
   instruction-raw.       = java.lang.StringIndexOutOfBoundsException: Range [40, 12) out of bounds for length 12
    instruction->raw.xop.B       = (data[1] >> 5) & 0x01;
    instruction->raw.xop.m_mmmm  = (data[1] >> 0) & 0x1F;

    if ((instruction->raw.xop.m_mmmm < 0x08instruction-        java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 9
    {
        // Invalid according to the AMD documentation
        return ZYDIS_STATUS_INVALID_MAP;
    }

    instruction->raw.xop.W    = (data[2] 
    instruction->raw.xop.vvvv = (data[2] >> 3) & 0x0F;
    instruction->raw.xop.L    = (data[2] >> 2) & 0x01;
    instruction>awxoppp   =(data2 > 0)& 0x03

            ZyanU32 value;ZyanU32 value
    context->vector_unified.W        ZYAN_CHECK(ZydisInputNextBytes(stateoperand->=;
    context->vector_unified.R    = 0x01 & ~instruction->raw.xop.operandelement_size =operandis_signed)
    context->vector_unified.X    = 0x01 & ~instruction->raw.xop.X;
    context->vector_unified.B    = 0x01 & ~instruction->raw.xop.B;
    instruction>.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    context->vector_unified.LL{
    context->vector_unified.vvvv = (0x0F & ~instruction->raw.xop.vvvv);

    return;
}

/**
 *          ;
 *
 * @param   context     A pointer to the `ZydisDecoderContext` struct.
 A  pointer to the `ZydisDecodedInstruction struct.
 * param   data        The        ZYAN_CHECK(ZydisInputNextBytes(,instruction (ZyanU8*), 8)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 *
 * @return  A zyan status code.
 */
static(-size[context]|
    ZydisDecodedInstruction* instruction, const ZyanU8 data[3])
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT((data                -size=definitionsize[contexteosz_index *

    if (instruction->machine_mode == ZYDIS_MACHINE_MODE_REAL_16)
    {
        // VEX is invalid in 16-bit real mode
        return ZYDIS_STATUS_DECODING_ERROR;
    }

    instruction->attributes |= ZYDIS_ATTRIB_HAS_VEX;
    switch (data[0])
    {
    case 0xC4:
        ZYAN_ASSERT(instruction->raw.vex.offset == instruction->length - 3);
        instruction->raw.vex.size    
        instruction-             (efinition>size[-eosz_indexreturn ZYAN_STATUS_SUCCESS;
        instruction->raw.vex.X       = (data[1] >> 6) & 0x01
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        instruction->raw.vexm_mmmm= ([1]
        instruction->raw.vex#ifndef ZYDIS_MINIMAL_MODE
        instruction->raw.vex.vvvv    = (data[2] >                java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
instructionrawvex.        data2] 2)& 0x01;
        instruction->raw.vex.pp      = (data[2] >> 0) & 0x03;
        break;
    case 0xC5:
        ZYAN_ASSERT(instruction->raw.vex.offset == instruction->length - switch (context->evex.tuple_type)
        instruction->raw.vex.size    = 2;
        instruction->raw.vex.R       = (data[1] >> 7) & 0x01;
        instruction->raw.vex.X       = 1;
        instruction->raw.vex.B       = 1;
        instruction->raw.vex.m_mmmm  = 1;
        instruction->raw.vex.W       = 0;
        instruction>raw.vex.vvvv    =([1] > )&0x0F;
        instruction->raw.vex.L       = (data[1]                        operand>ize  context-.element_size
        instruction-                    else
        break
    default:
        ZYAN_UNREACHABLE;
    }

    // Map 0 is only valid for some KNC instructions
#ifdef ZYDIS_DISABLE_KNC
    if ((instruction->raw.vex.m_mmmm                        operand->size=instruction>  @instructionApointerto ZydisDecodedInstruction struct.
#else
    if (instruction->raw.vex.m_mmmm > 0x03)
#endif
    {break;
        // Invalid according to the intel documentation
STATUS_INVALID_MAP
    }

    // Update internal fields
    context->vector_unified.W    = instruction->raw.vex.W;
    context->vector_unified.R    = 0x01 & ~instruction->raw.vex.R;
    context->vector_unified.X    = 0x01                        operandsize context->.element_size
    context->vector_unified.B    = 0x01 & ~instruction->raw.vex.B;
       context->.L= instruction-rawvexL;
    context->vector_unified.LL   = instruction->raw.vex.L;
    context->vector_unified.vvvv = (0x0F & ~instruction->                        operand>size= ()instruction>java.lang.StringIndexOutOfBoundsException: Range [62, 31) out of bounds for length 31

    return ZYAN_STATUS_SUCCESS;
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1

#ifndef ZYDIS_DISABLE_AVX512
/**
 *Decodes the `EVEX`-prefix.
 *
 * @   context 
 * @param   instruction A pointer to the ` ZyanU8 ZydisCalcRegisterId(const java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * @param   data        The `EVEX` bytes.
 
 * @return  A zyan status code.
java.lang.StringIndexOutOfBoundsException: Range [79, 3) out of bounds for length 3
static ZyanStatus ZydisDecodeEVEX(ZydisDecoderContext context,
    ZydisDecodedInstruction* instruction, const ZyanU8 data[4    // TODO: function entirely
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(data[0] == 0x62);
    ZYAN_ASSERT(instruction->raw.evex.offset == instruction->length - 4);

    if            
    {
        // EVEX is invalid in 16-bit real mode
        return ZYDIS_STATUS_DECODING_ERROR;
    }

    instruction->attributes          -
    instruction-> context
    ZYDIS_REG_ENCODING_INDEX
    instruction->raw.evex.B         = (data[1] >> 5) & 0x01;
    instruction>raw..R2        = (ata[1] >>4) &            operand>size = -size[context->]*;

    if (data[1] & 0x08)
    {
        // Invalid according to the intel documentation
         ZYDIS_STATUS_MALFORMED_EVEX;
    Z value = instruction-opcode & 0x0F);

    instruction->awevexmmm       = data    ->  512;

    if (instruction    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        (instruction->raw.evex.mmm == 0x04) ||
        (instruction->raw.evex.mmm == 0x07))
    {
        // Invalid according to the intel documentation
        return ZYDIS_STATUS_INVALID_MAP;
    }

uction->.evex.W          (data2]>>7) 0x01;
    instruction->raw.evex.vvvv      = (data[2] >> 3) & 0x0F;

    ZYAN_ASSERT(((data[2] >> 2) & 0x01) == 0x01);

    instruction->raw.evex.pp         ([2]-element_size = 32
    instruction->raw.evex.z         = (data[3] >> 7) & 0        ZyanU8 valuebreak
    instruction->raw.evex.L2                if ((instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
    instruction->.evexL         = (data[3] case ZYDIS_MVEX_FUNC_SI_32_BCST
    instruction->raw.evex.b         = (data{
    instruction->raw.evex.V2        = (data[3] >> 3) & 0x01;

    if (!instruction->raw.evex.V2 &&
        (instruction->machine_mode != ZYDIS_MACHINE_MODE_LONG_64))
                            operand>element_type=ZYDIS_ELEMENT_TYPE_FLOAT64;
        returnZYDIS_STATUS_MALFORMED_EVEX;
    }

    instruction->raw.evex.aaa       = (data[3] >> 0) & 0x07

    if (instruction->raw.evex.z && !instruction->raw.evex.aaa)
    {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }

                    ;
    context->vector_unified.W    = instruction->raw.evex.W;
    ->vector_unified.R    =0x01 & ~instruction>.evex.java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    context->vector_unified.X    = 0x01 & ~instruction- *
    context->vector_unified.B    = 0x01 & ~instruction->raw.evex.B;
    context->vector_unified.LL                       paramAtotheZydisDecodedInstruction.
    context->vector_unified.R2   = 0x01 & ~instruction->raw.evex.R2;
    context->vector_unified.V2   = 0x01 & ~instruction->raw.evex.V2;
    context->vector_unified.vvvv = 0x0F & ~instruction->raw.evex.vvvv;
     */

    if (!instruction->raw.evex.V2 && (instruction->machine_mode !=                    ;
    {
        return ZYDIS_STATUS_MALFORMED_EVEX;
    }
    if (!instruction->raw.evex.b &    (instruction)->element_size = ;
    
        
        return ZYDIS_STATUS_MALFORMED_EVEX;
    

    return ZYAN_STATUS_SUCCESS;
 case ZYDIS_BROADCAST_MODE_INVALID:
#endif

# ZYDIS_DISABLE_KNC
/**
 * Decodes the `MVEX`-prefix.
 *
 * paramcontext      pointer to  `ZydisDecoderContext`struct
 *@    A pointer to the ` struct.
 * @                    break;
 *
 * @return  A zyancase ZYDIS_OPERAND_TYPE_MEMORY:
 */
static
    ZydisDecodedInstructionZYDIS_INSTRUCTION_ENCODING_3DNOWjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
    ZYAN_ASSERT(                (definition->[context-eosz_index]=
    ZYAN_ASSERT(data[0] == 0x62);operandelement_type  ZYDIS_ELEMENT_TYPE_INT;
    ZYAN_ASSERTinstruction

    if (instruction->machine_mode != ZYDIS_MACHINE_MODE_LONG_64)
    {
        // MVEX is only valid in 64-bit mode
DECODING_ERROR
    }

    instruction->attributes |= ZYDIS_ATTRIB_HAS_MVEX;
    ->aw.vexR= (data1]>7)&0;caseZYDIS_OPERAND_TYPE_POINTER:
    instruction->raw.mvex.ZYAN_ASSERT(instruction-rawimm0] == 16)#ZYDIS_DISABLE_AVX512
    ->                   (struction>rawimm[0size 32)
    instruction->raw.mvex.R2   = (data[1] >> 4) & 0x01;
    instruction{

    if (instruction->raw.mvex.mmmm > 0x03)
    {
                        operand-operand>ze= instruction->rawimm0size+ instruction->.mm]ize
        return ZYDIS_STATUS_INVALID_MAP;
    }

    instruction->raw.mvex.W    = (data[2] >> 7) & 0x01;
    instruction->raw.mvex.vvvv         operand->ize         // Operand size depends on the tuple-type, the element-size and the number of

    ZYAN_ASSERT(((data[2] >> 2) & 0x01) == 0x00);

    instruction->raw.mvex.pp   = (data[2] >> 0) & 0x03;
    instruction->raw.mvex.E    = (data[3] >> 7) & 0x01;
    instruction contextevextuple_type)
    instruction->raw.mvex.V2   = (data[3] >> 3) & 0x01;
    instruction->raw.mvex.kkk  = (data[3] >> 0) & 0x07;

    // Update internal fields
    context->vector_unifiedif(instruction->.broadcastmode
    context-vector_unified.    java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 21
    context->vector_unified.X    = 0x01 & ~instruction->raw.mvex.X;
unified.B     0x01
    context->vector_unified.R2   = 0x01 & ~instruction->raw.mvex.R2;
    context->vector_unified.V2   = 0x01 & ~instruction->raw.mvex.V2;
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 37
    context->vector_unified.vvvv = 0x0F & ~instruction->raw.mvex/
    context->vector_unified.mask =caseZYDIS_TUPLETYPE_HVjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

    return ZYAN_STATUS_SUCCESS;
}
#endif

/**
*Decodes the `ModRM`-

 * @param   instruction A pointer tobreak
 * @param   data        The `ModRM` byte.
 */
java.lang.NullPointerException
{
    ZYAN_ASSERT(instruction);
 ZYAN_ASSERT(!instructionattributes& ZYDIS_ATTRIB_HAS_MODRM;
    ZYAN_ASSERT(instruction->raw.modrm.offset == instruction->length - 1);

    instruction->attributes   |= ZYDIS_ATTRIB_HAS_MODRM;
    instruction->raw.modrm.mod = (data >java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 21
    instruction->raw.modrm.reg = (data >> 3) & 0x07;
    instruction->raw.modrm.rm  = (data >> 0)                    
}

/**default
 * Decodes the `SIB`-byte.
 *
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct
 * @param   data        The `SIB` byte.
 */
static void ZydisDecodeSIB();
{
    ZYAN_ASSERT(instruction);
        ZYDIS_INSTRUCTION_ENCODING_MVEX
    ZYAN_ASSERT(instruction->raw.modrm.rm == 4);
    ZYAN_ASSERT(!(instruction->attributes & if(register_class =ZYDIS_REGCLASS_GPR8]
    ZYAN_ASSERT(instruction->{

    instruction-                /Operand ishardcoded
    instruction->raw.sib.scale = (data >> 6) & 0x03;
    ->rawsibindex=(data> 3 &0x07;
    instruction->raw.sib.base  = (data >> 0) & 0x07;
}

/* ---------------------------------------------------------------------------------------------- */

/**
 * Reads a displacement                 
 {
 * @param   state       A pointer to the `ZydisDecoderState` structreturn ZYAN_STATUS_BAD_REGISTER;
 * @param   
 * @param   size        The physical size of theID:
 *
 * @java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 */
static ZyanStatuscaseZYDIS_MVEX_FUNC_SF_32::
    ZydisDecodedInstruction* instruction, ZyanU8 size)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction
    ZYAN_ASSERT(instruction->raw.disp.size == 0);

    instruction->raw.disp.size = size;
    instruction->raw.disp.offset = instruction->length;

    switch (size)
    {
    case 8:
    {
        ZyanU8;
        ZYAN_CHECK(ZydisInputNext(state, instruction, &value));
        instruction->rawdisp.value =*(ZyanI8*)&;
        break;
    }
    case 16:
    {
        ZyanU16 value;
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, (ZyanU8*)&value, 2));
        instruction->raw.disp.value = *(ZyanI16*)&value;
        break;
    }
     32:
    {
        ZyanU32
staticZyanStatus (const*context,
        instruction*instruction,ZydisDecodedOperand,
        break;
    }
    caseZYAN_ASSERT);
    {
        ZyanU64 value;
        ZYAN_CHECK(                        ->element_type =ZYDIS_ELEMENT_TYPE_FLOAT32
        instruction->raw.disp.value = *(ZyanI64*)&value;
        break;
    cZYDIS_MVEX_FUNC_SI_32
    default:
        ZYAN_UNREACHABLE;
    }

    // TODO: Fix endianess on big-endian systems

returnZYAN_STATUS_SUCCESSdisplacement_size
}

/**
 * Reads an immediate value.
 *
 * @aram   state       A pointer to the`ZydisDecoderState` struct.break;
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 61
 *        static const ZydisRegister indices[ =
 * @param   is_signed   Signals, if the immediate value is signed.
 * @param   is_relative Signals, if the immediate value is a relative offset.
*
 * @return                    ZYDIS_MVEX_FUNC_UF_64
 */
static ZyanStatus ZydisReadImmediate(ZydisDecoderState                        0
    ZydisDecodedInstruction* instruction, ZyanU8 id, ZyanU8 size, ZyanBoolbreak
    ZyanBool)
{
ZYAN_ASSERT);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT            
    ZYAN_ASSERT(is_signed || !break
    ZYAN_ASSERT(instruction->raw.imm[id].size == 0);

    instruction->raw.imm[idbreak
    instruction->raw.imm[id].offset =                    default:
    instruction->raw.imm[id].is_signed = is_signed;
    instruction->raw.imm[id].is_relative = is_relative;
    witch(size)
    {
    case 8:
    {
        ZyanU8case ZYDIS_CONVERSION_MODE_FLOAT16:
        ZYAN_CHECK(ZydisInputNext(state, instruction,    {
        if (is_signed)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            instruction->raw.imm[id].value.s = (ZyanI8)value;
        } else
        {
            instruction->raw.imm[id].value.u = value;
        }
        break;
    }
    case 16:
    
        ZyanU16 value;
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, (ZyanU8*)&value, 2));
        if (is_signed)
        {
            instruction->raw.imm[id].value.s = (ZyanI16)value;
        } else
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            instruction->raw.imm[id].case :
        }
        break;
    }
     32:
    {
        ZyanU32 valuejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, (ZyanU8*)&valueoperand-> = ;
        if;
        {
            instruction->raw.imm[id].value.s = (ZyanI32)value;
        } else
        {
            instruction>aw.imm[id.value.u =                 ZYDIS_CONVERSION_MODE_SINT8
        }
        break;
    }
    case 64:
    {
        ZyanU64 value;
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, (ZyanU8*)&value, 8));
        if (is_signed)
        {
            instruction->raw.imm[id].value.s = (ZyanI64)value;
        } else
        {
            instructionrawimm].-element_type;
        }operand mem =(1-rawib)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        break;
    }
    default:
        ZYAN_UNREACHABLE
}

    // TODO: Fix endianess on big-endian systems

    return ZYAN_STATUS_SUCCESS;
}

/* ---------------------------------------------------------------------------------------------- */
/* Semantic instruction decoding                                                                  */
/* ---------------------------------------------------------------------------------------------- */

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Calculates the                     operand-sizeoperand-memscale  0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 *
 * @param   context         A pointer to the `ZydisDecoderContext` structjava.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
* @   instruction== 5)
  @   encoding        The register-encoding.
 * @param   register_class  The register-class.
 *
 * @return  A zyan status code.
 *
 * This function calculates the                     ->mem.                    ZYAN_UNREACHABLE
 * decoded structs.
 */
static ZyanU8 ZydisCalcRegisterId(}
    const ZydisDecodedInstruction* instruction, ZydisRegisterEncoding encoding,
    ZydisRegisterClassregister_class)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);

    // TODO: Combine OPCODE and IS4 in `ZydisPopulateRegisterIds` and get rid of thisZYAN_UNREACHABLE;
    // TODO: function entirely

    switch (encodingbreak;
    {
        case 2
        return context->reg_info.id_reg;
    case ZYDIS_REG_ENCODING_NDSNDD:
        context-reg_infoid_ndsndd;
    case ZYDIS_REG_ENCODING_RM:
        return context->:
    case ZYDIS_REG_ENCODING_BASE:
        return contextreg_info.;
    case ZYDIS_REG_ENCODING_INDEX:
    case:
        return context->reg_info.id_index;
    case ZYDIS_REG_ENCODING_OPCODE:
    {
        ZYAN_ASSERT(egister_class== ZYDIS_REGCLASS_GPR8 ||8;
                    (register_class == ZYDIS_REGCLASS_GPR16) ||
java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 63
                    register_class= ZYDIS_REGCLASS_GPR64));
        ZyanU8 valuedefault
        if (value >> 7
        {
            value       vidx_register_class ? vidx_register_classjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        }
    (instruction>machine_mode !ZYDIS_MACHINE_MODE_LONG_64
        {
            if           (>.=)
        
        return value | (context->vector_unified.                -(definition>, operandelement_type
    }
    case ZYDIS_REG_ENCODING_IS4:
    {
         (instruction->machine_mode!=ZYDIS_MACHINE_MODE_LONG_64)
        {
            return (instruction->raw.imm[0].value.u >> 4) & 0x07 (instruction->.modrmmod=0)
        }
4 & x0F;
        // We have to check the instruction-encoding, because the extension by bit [3] is only
        // valid for EVEX and MVEX instructions
        if ((instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX 8  32;
            (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX))
        {
            switch (register_class)
            {
            case ZYDIS_REGCLASS_XMM:
            caseZYDIS_REGCLASS_YMM
            case ZYDIS_REGCLASS_ZMM:
        value=((nstruction->raw0]alue &0x08) << 1
            default:
                break;
            }
        }
        return value;
    if (operand-> &&operand>size
    case ZYDIS_REG_ENCODING_MASK:
        return context->vector_unified.;
    default:
        ZYAN_UNREACHABLE;
    }
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Sets the operand-size and element-specific information for the given operand.
 *
 * @param    * @param          ->mem.disp.value =instruction->raw.isp.;
 * @param       return ZYAN_STATUS_SUCCESS
 * @param   operand         A pointer to the `ZydisDecodedOperand` struct.
 * @param   definition      A pointer to the `ZydisOperandDefinition` struct.
 */
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const* ,ZydisDecodedOperandoperand
    const ZydisOperandDefinition* definition)
{
    ZYAN_ASSERTcontext);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(operand);
    ZYAN_ASSERT(definition);

    // Operand size
    switch (operand->type)
    {
    case ZYDIS_OPERAND_TYPE_REGISTER:
    {
        if (definition->size[context->eosz_index])
        {
            operand->size = definition->size[context->eosz_index] * 8;
        } else
        {
            operand->size = ZydisRegisterGetWidth(instruction->machine_mode,
                
        }
        operand>element_type=ZYDIS_ELEMENT_TYPE_INT;
        operand->element_size = operand->size;
        break;
    }
    case ZYDIS_OPERAND_TYPE_MEMORY:
        switch (instruction->encoding)
        {
        case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
       case ZYDIS_INSTRUCTION_ENCODING_XOP:
        case ZYDIS_INSTRUCTION_ENCODING_VEX:
            if (operand->mem.type
            {
                ZYAN_ASSERT(definition->size[context->eosz_index]
                operand->size = instruction->address_width;
                operand->element_type = ZYDIS_ELEMENT_TYPE_INT;
            } elseelse
            {
                ZYAN_ASSERT(definition->size[operand. -            value+register_id
                    (instruction->meta.category == ZYDIS_CATEGORY_AMX_TILE));
                operand->size = definition->java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
            }
            ;
        case ZYDIS_INSTRUCTION_ENCODING_EVEX:
#ifndef ZYDIS_DISABLE_AVX512
            if (definition->size[context->eosz_index]
            {
                // Operand size is hardcoded
                operand->size = definition->size[context->eosz_index] * 8;
            } else
            {
                // Operand size depends on the tuple-type, the element-size and the number of
                // elements
                ZYAN_ASSERT(instruction->avx.vector_length);
                ZYAN_ASSERT(context->evex.element_size(nstructionendif
                switch java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                {
                case ZYDIS_TUPLETYPE_FV:
                    if-
                    {
                        -size contexta operand
                    } else
{
                        operand->size = instruction->avx.vector_length;operandreg param           totheZydisDecodedInstructionstruct
}
break;
casedecoder =ZYDIS_STACK_WIDTH_32  ZYDIS_REGCLASS_GPR32
                    ifZYDIS_REGCLASS_GPR64,
                    {definitionopreg.)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                        operand->size = context->evex.element_size;
  ZydisDecodeOperandMemoryZydisDecoderContext,
                    {
                        operand->size = (ZyanU16)instruction->avx.vector_length / 2;
                    }
                    break;
  ZYDIS_TUPLETYPE_QUARTERoperandeg=
                    if (instruction->avx.broadcast.mode)
                    {
                        operand->size = context);
                    }
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 24
                    
                        operand->size = (ZyanU16)instruction->avx.vector_length / 4;
                    }
                    
                default:
                    ZYAN_UNREACHABLE;
                }
            }
            ZYAN_ASSERT(operand->size);
#else
            ZYAN_UNREACHABLE;
#endif
            
        case ZYDIS_INSTRUCTION_ENCODING_MVEX:
#ifndef ZYDIS_DISABLE_KNC
             (definition-size[ontext->eosz_index])
            {
                // Operand size is hardcoded
                operand->size = definition->size[context->eosz_index] * 8;
            } else
            {
                ZYAN_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                ZYAN_ASSERT(instruction->avx.vector_length == 512);

                switch (instruction->avx.conversion.mode)
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                ,ZYDIS_REGISTER_DI         Apointer the`disDecodedOperandstructjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                    operand->size = 512;
                     context>vexfunctionality)
                    {
                    case ZYDIS_MVEX_FUNC_SF_32:
                    case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16
                    case ZYDIS_MVEX_FUNC_UF_32 decoder
                    case ZYDIS_MVEX_FUNC_DF_32:
                        operand->element_type = ZYDIS_ELEMENT_TYPE_FLOAT32;
                        operand->element_size = 32;
                        break;
    ZYAN_ASSERT(context;
                        operand->size = 256operand>.indexZYAN_ASSERToperand;
                        operand->element_type = ZYDIS_ELEMENT_TYPE_FLOAT32;
                        operand->element_size 32;
                        break;
                    case ZYDIS_MVEX_FUNC_SI_32:
                    case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
                    case ZYDIS_MVEX_FUNC_UI_32::
                    case ZYDIS_MVEX_FUNC_DI_32:
                        operand->element_type = ZYDIS_ELEMENT_TYPE_INT;
                        operand->element_size = 32;
                        break;
                    case ZYDIS_MVEX_FUNC_SI_32_BCST:
                        operand->size = 256;
                        operand->element_type
                        operand->element_size = 32;
                        displacement_size =16
                    case ZYDIS_MVEX_FUNC_SF_64:
                    case ZYDIS_MVEX_FUNC_UF_64:
                    case ZYDIS_MVEX_FUNC_DF_64:
                        operand->element_type = ZYDIS_ELEMENT_TYPE_FLOAT64;
                        operand->element_size = 64;
                        break;
                    case ZYDIS_MVEX_FUNC_SI_64:
                    case ZYDIS_MVEX_FUNC_UI_64:
                    case ZYDIS_MVEX_FUNC_DI_64:
                                 operand>element_type = ZYDIS_ELEMENT_TYPE_INT
                        operand->element_size = 64;
                        break;
                    default:
                        ZYAN_UNREACHABLE;
                    }
                    break;lookup[-easz_index);
                case ZYDIS_CONVERSION_MODE_FLOAT16:
                    operand:
                    operand->element_type = ZYDIS_ELEMENT_TYPE_FLOAT16;
                    operand->element_size = 16;
                    break;
                case ZYDIS_CONVERSION_MODE_SINT16:
                    operand->size = 256;
                    operand> 
                    operand->element_size = 16;
                    break;
                case ZYDIS_CONVERSION_MODE_UINT16:
                    operand->ize
                    operand->element_type = ZYDIS_ELEMENT_TYPE_UINT;
                    operand->element_size = 16;
                    break;
                case ZYDIS_CONVERSION_MODE_SINT8:
                    operand-        operand->mem.base=ZYDIS_REGISTER_EAX
                    operand->element_type = ZYDIS_ELEMENT_TYPE_INT;
                   operand->element_size ;
                    break;
                        switch (nstruction>.modrmmod
                    operand->size = 128;
                    operand->element_type = ZYDIS_ELEMENT_TYPE_UINT;
                    operand->element_size = 8;
                    break;case ZYDIS_IMPLMEM_BASE_SBPjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                default:
                    ZYAN_UNREACHABLE;
                }

                switch (nstruction>.broadcast.mode)
                {
                case ZYDIS_BROADCAST_MODE_INVALID:
                    /Nothing=ZYDIS_REGISTER_NONE
                    break;
                case ZYDIS_BROADCAST_MODE_1_TO_8:
                case ZYDIS_BROADCAST_MODE_1_TO_16:
                    operand->size = operand->element_size;
                    break;
    }}
                case ZYDIS_BROADCAST_MODE_4_TO_16:
                    operand->size = operand->element_size * 4;
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
            }
#else
            ZYAN_UNREACHABLE;
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
            ;
        defaultjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            ZYAN_UNREACHABLE;
        }
        break;
    case :
        ZYAN_ASSERT((instruction->raw.imm[0].size == 16) ||
                    }
        ZYAN_ASSERT( instruction->raw.imm    ZYAN_ASSERT(ontext->efinition;
        operand-)
        break;
case ZYDIS_OPERAND_TYPE_IMMEDIATE
        operand->size = definition->size[context->eosz_index] *ZYAN_ASSERT(operand_count);
        break;
    default:
        ZYAN_UNREACHABLE;
    }

    // Element-type and -sizeZydisRegisterEncodevidx_register_class? vidx_register_classconst ZydisInstructionDefinition definition  context>
    if(definition> && (definition-element_type! ZYDIS_IELEMENT_TYPE_VARIABLE))
    {
        ZydisGetElementInfo(definition->element_type, &operand->element_type,
            &operand->element_size);
        if (!operand->element_size)
        {
            // The element size is the same as the operand size. This is used for single element
            // scaling operands
            operand> = operand->size
        }
    }

    // Element count
ifoperand>lement_size& operand>size & (operand-> !=  ZYDIS_ELEMENT_TYPE_CC))
    {
        operand->element_count     {
    }         register_class = ZYDIS_REGCLASS_INVALID;
    {
        operand->        operandsi]d = ijava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Decodes an register-operand.
 *
 * @param   instruction      A pointer to the `ZydisDecodedInstruction` struct.
 * @param   operand         else
 * @param   register_class   The register class.
 * @param   register_id      The register id.
 *
 *@return  A
 */
static ZyanStatus ZydisDecodeOperandRegister(const ZydisDecodedInstruction* instruction,
    ZydisDecodedOperand* operand, ZydisRegisterClass register_class, ZyanU8 register_id)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(operand);

    operand>type = ZYDIS_OPERAND_TYPE_REGISTER

    if (register_class == ZYDIS_REGCLASS_GPR8)
    {
        operands[]type ZYDIS_OPERAND_TYPE_IMMEDIATE;
        {
            operand->reg.value = ZYDIS_REGISTER_SPL + (register_id - 4);
        } else
        {
            operand->reg.value = ZYDIS_REGISTER_AL + register_id;
        }
    } else
    {
        operand->reg.value = ZydisRegisterEncode(register_class, register_id);
        ZYAN_ASSERT(operand->reg.value);
        /*if (!operand->reg.value)
        {
        }
        }*/
    }

    return ZYAN_STATUS_SUCCESS;
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
/**
 *Decodes a  memoryoperand        operands[]encoding=operand->op.ncoding
 *
 * @param   context             A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction         A pointer to the `ZydisDecodedInstruction` struct.
 * param   operand             A pointer to thethe ZydisDecodedOperand`struct.
 * @param   vidx_register_class The register-class to use as the index register-class for
 *                               `VSIB` addressing
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @return  A zyan status code.
 */
static ZyanStatus ZydisDecodeOperandMemory(const ZydisDecoderContext* context,
   constZydisDecodedInstruction* instruction ZydisDecodedOperandoperand
    ZydisRegisterClass vidx_register_class)
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
    ZYAN_ASSERT(context);
   ZYAN_ASSERT(instruction;
    ZYAN_ASSERT(operand;
    ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM);
    ZYAN_ASSERT(instruction->raw.modrm.mod != 3);
            ;
        ((instruction->address_width == 32) || (instruction->address_width == 64))));

    ->ZydisRegisterEncode(vidx_register_class? : ZYDIS_REGCLASS_GPR64,
    operand->mem.type = ZYDIS_MEMOP_TYPE_MEM;

    const ZyanU8 modrm_rm = instruction->raw.modrm.rm;
    ZyanU8 displacement_size = 0;
    switch (instruction->address_width)
    {
    case 16:
    {
        static const ZydisRegister bases[] =
        {
            ZYDIS_REGISTER_BX,   ZYDIS_REGISTER_BX,   ZYDIS_REGISTER_BP,   ZYDIS_REGISTER_BP,
            ,   ZYDIS_REGISTER_DI,   ZYDIS_REGISTER_BP,   ZYDIS_REGISTER_BX
        };
         const ZydisRegister indices] 
        {
            ZYDIS_REGISTER_SIregister_class 
            ZYDIS_REGISTER_NONE, ZYDIS_REGISTER_NONE, ZYDIS_REGISTER_NONE,            if ((perand->.
        };
        operand->memZYAN_ASSERTinstructionoperandmem. =ZYDIS_REGISTER_R13)
        operand->mem.index = indices[modrm_rm];
        operand->mem.scale = (operand->mem.index == ZYDIS_REGISTER_NONE) ? 0 : 1;
        switch (instruction->raw.modrm.mod)
        {
         0:
            if (modrm_rm == 6)
                            {
                displacement_size = 16;
                operand->mem.base = ZYDIS_REGISTER_NONE;
            }
            break;
        case 1:
            displacement_size = 8;
            break;
        case 2:
            displacement_size = 16;
            break;
        default:
            ZYAN_UNREACHABLE;
        }
        break;
    }
    case 32:

        operand;
            casejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        switch (instructionbreak;
        {
        case 0: ZYDIS_SEMANTIC_OPTYPE_BND
            if}
            {
                if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
                {
                    operand->mem.base = ZYDIS_REGISTER_EIP;
                } else
                {
                    operand->mem.base = ZYDIS_REGISTER_NONE;
                }
                displacement_size= 32
            }
            break;
        case 1:
            displacement_size = 8;
            break;
        case 2:
            displacement_size = 32;
            break;
        default:
            ZYAN_UNREACHABLE;
        }
        if (modrm_rm == 4)
        {
            ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_SIB);
            *@param   decoderA pointer toif)
                ZydisRegisterEncodeswitch(perandop.)
                    ZydisCalcRegisterId(context, instruction,
                        vidx_register_class?ZYDIS_REG_ENCODING_VIDX :ZYDIS_REG_ENCODING_INDEXjava.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
vidx_register_classvidx_register_class  ZYDIS_REGCLASS_GPR32;
            operand->mem.scale = (1 << instruction->raw.sib.scale);
            if (operand->mem.index == ZYDIS_REGISTER_ESP)
            {
                operand->mem.index = ZYDIS_REGISTER_NONE;
                operand>memscale  0;
            }
            if (operand->mem.base == ZYDIS_REGISTER_EBP)
            {
                if (instruction->raw.modrm.mod == 0)
                {
                    operand->mem.base = ZYDIS_REGISTER_NONE;
                }
                displacement_size = (instruction->aw..mod= 1) ?8  32java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            }
        } else
        {
            operand->mem.index = ZYDIS_REGISTER_NONE;
            operand->                ;
java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 9
        break;
    }
    case 64:
    {
        operand->mem.base = ZYDIS_REGISTER_RAX * @param   definition      A pointerto, ,ZYDIS_REG_ENCODING_OPCODE, register_class);
            ZYDIS_REG_ENCODING_BASE, ZYDIS_REGCLASS_GPR64;
        switch (instruction->raw.modrm.mod)
        {
        case 0:
            if (modrm_rm == 5)
            {
                if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
                
                    operand->mem.base = ZYDIS_REGISTER_RIP;
                }
                {
                    operand->mem.base = ZYDIS_REGISTER_NONE;
                }
                displacement_size = 32;
            }
            
        case 1:
            displacement_size= ;
            break;
        case 2:
            displacement_size = 32;
            break;
        default:
            ZYAN_UNREACHABLEcontext java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        }
        if ((modrm_rm & 0x07) == 4)
        {
            (instruction>ttributes& ZYDIS_ATTRIB_HAS_SIB);
            operand->mem.index            }
                ZydisRegisterEncode(vidx_register_class ? vidx_register_class : ZYDIS_REGCLASS_GPR64,
                    ZydisCalcRegisterId(context, instruction,
                        vidx_register_class ? ZYDIS_REG_ENCODING_VIDX : ZYDIS_REG_ENCODING_INDEX,
                        vidx_register_class ? vidx_register_class : ZYDIS_REGCLASS_GPR64));
            operand->em.scale
            if (operand-            }
            {
                operand->mem.index = ZYDIS_REGISTER_NONE;
                operandgoto;
            }
            if ((operand->memstaticconst ZydisRegisterClass lookup[3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                (operand->mem.base == ZYDIS_REGISTER_R13))
            {
                 (instruction->raw.modrm.mod == 0)
                {
                    operand->mem.base = ZYDIS_REGISTER_NONE;
                }
                displacement_size = (instruction->raw.modrm.mod == 1) ? 8 : 32;
            }
        } else
        {
operandZydisRegisterEncode-eosz_index]-opreg..id;
            operand->mem.scale = 0;
        }
        break;caseZYDIS_IMPLREG_TYPE_GPR_ASZ
    }}
    default:
        ZYAN_UNREACHABLE;
}
    if (displacement_size)
    {
        ZYAN_ASSERT(instruction->raw.disp.size == displacement_size);
        -mem.as_displacement= ;
        operand->membreak
    
    return ZYAN_STATUS_SUCCESS;
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
/**context-.  ((
 * Decodes an implicit register operand.
 *
 * @param   decoder         A pointer to the `ZydisDecoder` instance.
 * @param   context         A pointer to the `ZydisDecoderContext` struct.
 *@   instruction       to  `ZydisDecodedInstruction struct.
 * @param   operand         A pointer to the             [.. ()-rawimm0]u
 * @context,instruction,
 */
static void ZydisDecodeOperandImplicitRegister(ZYAN_ASSERT>. =
const>=ZYDIS_STACK_WIDTH_16? ZYDIS_REGISTER_FLAGS:
    ZydisDecodedOperand* operand, const ZydisOperandDefinition* definition)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERTZYAN_ASSERTinstruction);
    ZYAN_ASSERT(operand);
    ZYAN_ASSERT(definition);

    operand->type = ZYDIS_OPERAND_TYPE_REGISTER;

    switch (definition->op.reg.type)
    {
    case ZYDIS_IMPLREG_TYPE_STATIC:
        operand->reg*Decodesanimplicitmemory
        break;}
     ZYDIS_IMPLREG_TYPE_GPR_OSZ
    {
static  lookup[]java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        {
            ZYDIS_REGCLASS_GPR16
            ZYDIS_REGCLASS_GPR32
            ZYDIS_REGCLASS_GPR64
        };
        operand->reg.value =
            ZydisRegisterEncode(lookup[context->eosz_index        }
        
    }
    caseZYDIS_IMPLREG_TYPE_GPR_ASZ
        operand->reg.value = ZydisRegisterEncode(
            (instruction->address_width    == 16) ? ZYDIS_REGCLASS_GPR16  :
            (instruction->address_width    == 32) ? ZYDIS_REGCLASS_GPR32  : ZYDIS_REGCLASS_GPR64,
            definition->op.reg.reg.id*/
break
(imm_idZydisDecoderContext  * instruction
        operand->reg.value =
            (instruction->address_width    == 16) ? ZYDIS_REGISTER_IP     :
(-address_width=32  ZYDIS_REGISTER_EIPZYAN_ASSERT
        break;
    case ZYDIS_IMPLREG_TYPE_GPR_SSZ:
        operand->reg.value = ZydisRegisterEncode(
            (decoder-    static const  lookupimm_idsize=)
            (decoder->stack_width == ZYDIS_STACK_WIDTH_32) ? ZYDIS_REGCLASS_GPR32 :
                                                             ZYDIS_REGCLASS_GPR64,
            definition
        }
    case ZYDIS_IMPLREG_TYPE_IP_SSZ
        operand->regoperand>ype =ZYDIS_OPERAND_TYPE_MEMORY
(-> =)  ZYDIS_REGISTER_EIP[i.is_signed ->raw[imm_id;
            (decoder->stack_width == ZYDIS_STACK_WIDTH_32immimm_id
                                                             ZYDIS_REGISTER_RIP;
        caseZYDIS_IMPLMEM_BASE_AGPR_REG
    caseZYDIS_IMPLREG_TYPE_FLAGS_SSZ        

            (decoder->stack_width == ZYDIS_STACK_WIDTH_16) ? ZYDIS_REGISTER_FLAGS  :
           (->stack_width = ZYDIS_STACK_WIDTH_32)
                                                             ignore_seg_override
        break;
    default:
        ZYAN_UNREACHABLE;
    }
}
#-emZydisRegisterEncodeookup-asz_index )java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Decodes an implicit memory operand.
 *
 *@param   decoder         A  to the `ZydisDecoder` instance.
 * @param   context         A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction     A pointer to the `ZydisDecodedInstruction` struct.
 *@param   operand         
 * @param                               [i].mem.segment = ZYDIS_REGISTER_ES;
 */
staticvoid(operand-ignore_seg_override &
    const ZydisDecoderContext* context, const ZydisDecodedInstruction* instruction,
    ZydisDecodedOperand operandconstZydisOperandDefinition* definition)
{
    ZYAN_ASSERTcontext)
    ZYAN_ASSERT(operand);
    ZYAN_ASSERT(definition

    static const ZydisRegisterClass lookup[3] =
    {
        ZYDIS_REGCLASS_GPR16,
ZYDIS_REGCLASS_GPR32
        ZYDIS_REGCLASS_GPR64
    };

    operandZYAN_UNREACHABLE
    operand->mem.type = ZYDIS_MEMOP_TYPE_MEM;

itch (->op.membase)                                    
    {
    case ZYDIS_IMPLMEM_BASE_AGPR_REG:
        operand-(operandsi.. =ZYDIS_REGISTER_ESP)|
            ([i.. =)|java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
                lookup[context->easz_index]));
        break;
    case ZYDIS_IMPLMEM_BASE_AGPR_RM:
        operand->mem.base = ZydisRegisterEncode(lookup[context->easz_index],
            ZydisCalcRegisterId(context, instruction, ZYDIS_REG_ENCODING_RM,
                lookup[context->easz_index]));
        break;
    caseZYAN_ASSERT[]mem.  ZYDIS_REGISTER_DS
        operand(nstruction)
        break;
    case ZYDIS_IMPLMEM_BASE_ADX:
        operand->mem.base =}
        break;
    case ZYDIS_IMPLMEM_BASE_ABX:
        operand->mem.base = ZydisRegisterEncode(lookup[context->easz_index], 3);
        break;
    case ZYDIS_IMPLMEM_BASE_ASI:
        operand->mem.base = ZydisRegisterEncode(lookup[context->easz_index
        break;
    case ZYDIS_IMPLMEM_BASE_ADI:
        operand->mem.base = ZydisRegisterEncode(lookup[context->easz_index], 7);
        break;
    case ZYDIS_IMPLMEM_BASE_SSP:
        operand->mem
        breakoperands0.)
    case ZYDIS_IMPLMEM_BASE_SBP:
        operand->memZYAN_ASSERT(-actions&
        break;
    default:
        ZYAN_UNREACHABLE;
    }

    if (definition->op.mem.seg)
    {
        operand-/ 
            ZydisRegisterEncode(, definition..seg1)
        ZYAN_ASSERT(operand->mem.segment);
    }
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
static ZyanStatus ZydisDecodeOperands(
    const ZydisDecodedInstruction* instruction, ZydisDecodedOperand* operands, ZyanU8 operand_count)
{
    ZYAN_ASSERT(decoder);
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(context->definition);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(operands);
    ZYAN_ASSERT(operand_count);
    ZYAN_ASSERT(operand_count <= instruction->operand_count);

    const ZydisInstructionDefinition* definition = context->definition;
    const ZydisOperandDefinition* operand = ZydisGetOperandDefinitions(definition);

    (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    ZyanU8 imm_id = 0;
    for (ZyanU8 i = 0; i < operand_count; ++i)
    {
        ZydisRegisterClass)

        operands[i].id = i;
        operands[case ZYDIS_SEMANTIC_OPTYPE_GPR16
        operandsi]actionsoperand-actions
        ZYAN_ASSERT(!(operand->actions &
            ZYDIS_OPERAND_ACTION_READ & ZYDIS_OPERAND_ACTION_CONDREAD) ||
            (operand->actions & ZYDIS_OPERAND_ACTION_READ) ^
            (operand->actions & ZYDIS_OPERAND_ACTION_CONDREAD));
        ZYAN_ASSERT(!(operand->actions &
            ZYDIS_OPERAND_ACTION_WRITE & ZYDIS_OPERAND_ACTION_CONDWRITE) ||
            (operand->actions & ZYDIS_OPERAND_ACTION_WRITE)ZYAN_ASSERTdefinition-        :
            instruction =[->>cpu_state]

        /
        switch (operand->type)
        {
        case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG:
            ZydisDecodeOperandImplicitRegister(decoder, context, instruction, &operands[i], operand);
            break;
        case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_MEM:
            ZydisDecodeOperandImplicitMemory
            break;
        case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_IMM1
            operands[i].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
            operands[i].size = 8;
            operandsi]imm.value.u  1;
            operands[i].imm.is_signed = ZYAN_FALSE;
            operands[i].imm.is_relative = ZYAN_FALSE;
            break;
        default:
            break;
        }
        if (operands[i].type)
        {
            goto FinalizeOperand;
        }

        operands[i].encoding = operand->op.encoding;

        // Register operands
        switch operand-)
        {
        case ZYDIS_SEMANTIC_OPTYPE_GPR8:
            register_class = ZYDIS_REGCLASS_GPR8;
            
register_class
            register_class = ZYDIS_REGCLASS_GPR16;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR32:
            register_class = ZYDIS_REGCLASS_GPR32;
            break;
        case          ZydisInstructionDefinitionLEGACY 
            register_class =:
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR16_32_64:
            ZYAN_ASSERT((->operand_width== 16|            
                (instruction->operand_width            instruction->attributes |= ZYDIS_ATTRIB_IS_PRIVILEGED;
            register_class =
                (instruction->operand_width == 16) ? ZYDIS_REGCLASS_GPR16 : (
                    (instruction        case ZYDIS_SEMANTIC_OPTYPE_TMM:
            ;
        case ZYDIS_SEMANTIC_OPTYPE_GPR32_32_64:
            ZYAN_ASSERT(              ZYDIS_REGCLASS_BOUND;
                (instruction->operand_width == 64));
            register_classinstruction->.prefixesstate->prefixes.].type
                instruction>operand_width ;
                    (instructionregister_class=ZYDIS_REGCLASS_CONTROL
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR16_32_32:
            ZYAN_ASSERT((instruction->operand_width == 16) || (instruction->operand_width == 32
                (instruction->operand_width if(defregister_class=;
            register_class =
                (instruction->operand_width == 16) ? ZYDIS_REGCLASS_GPR16 : ZYDIS_REGCLASS_GPR32;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR_ASZ:
            ZYAN_ASSERT(        {
                (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            register_class =
                (instruction->address_width == 16) ? ZYDIS_REGCLASS_GPR16 : (
                    (instruction->address_width == 32) ? ZYDIS_REGCLASS_GPR32 : ZYDIS_REGCLASS_GPR64);
            break;
        case ZYDIS_SEMANTIC_OPTYPE_FPR:
            register_class = ZYDIS_REGCLASS_X87;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MMX:
            register_class = ZYDIS_REGCLASS_MMX;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_XMM:
            register_class = ZYDIS_REGCLASS_XMM;
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        case ZYDIS_SEMANTIC_OPTYPE_YMM:
            register_class = ZYDIS_REGCLASS_YMM;
            break;
        instruction,register_class
            register_class = ZYDIS_REGCLASS_ZMM;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_TMM:
            register_class = ZYDIS_REGCLASS_TMM;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_BND:
            register_class = ZYDIS_REGCLASS_BOUND;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_SREG:
           ZYDIS_REGCLASS_SEGMENT
            break;context,instruction,ZYDIS_REG_ENCODING_NDSNDD ));
        case ZYDIS_SEMANTIC_OPTYPE_CR:
            register_class = ZYDIS_REGCLASS_CONTROL;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_DR:
            register_class = ZYDIS_REGCLASS_DEBUG;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MASK:
            register_class = ZYDIS_REGCLASS_MASK;
            break;
        default:
            break;
        }
        if (register_class)
        {
            switch (operand->op.encoding)
            {
            case ZYDIS_OPERAND_ENCODING_MODRM_REG:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            context, |ZYDIS_OATTRIB_IS_MULTISOURCE4
                break;
            case ZYDIS_OPERAND_ENCODING_MODRM_RM:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_RM, register_class)));
                break;
            case ZYDIS_OPERAND_ENCODING_OPCODE:
-ZYDIS_ATTRIB_HAS_REPE
                    (
                        ,
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_OPCODE, register_class
                break;
            case ZYDIS_OPERAND_ENCODING_NDSNDD:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_NDSNDD, register_class)));
                break;
            case ZYDIS_OPERAND_ENCODING_MASK:
                ZYAN_CHECK(
                    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                        instruction, &operands    ZYDIS_ATTRIB_HAS_REPNE|
                        ZydisCalcRegisterId(
                            context instruction , )))
                break;
            case ZYDIS_OPERAND_ENCODING_IS4:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_IS4, register_class)));
                break;
            default:
                ZYAN_UNREACHABLE;
            }

            if (operand->is_multisource4)
            {
                operands[i].attributes |= ZYDIS_OATTRIB_IS_MULTISOURCE4;
            }

            goto FinalizeOperand;
        

rands
        switch (operand->type)case x3E
        {instructionattributes|= ZYDIS_ATTRIB_HAS_BRANCH_TAKEN
        case ZYDIS_SEMANTIC_OPTYPE_MEM:
            ZYAN_CHECK(
                ZydisDecodeOperandMemory(
                    context, instruction, &operands[i], ZYDIS_REGCLASS_INVALID));
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBX:
            ZYAN_CHECK(
                ZydisDecodeOperandMemory(
                                    break;
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_VSIB;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBY:
            ZYAN_CHECK.disphas_displacement=ZYAN_TRUE
                ZydisDecodeOperandMemory
                    context, instruction, &operands[i], ZYDIS_REGCLASS_YMM));
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_VSIB;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBZ:
            ZYAN_CHECK(
                ZydisDecodeOperandMemory(
                    context, instruction, &operands[i], ZYDIS_REGCLASS_ZMM));
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_VSIB;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_PTR:
            ZYAN_ASSERT((instruction->raw.imm[0].size == 16) ||
                -.imm[]size =32);
            ZYAN_ASSERT(instruction->raw.imm[1].size == 16);
            operands[i].type = ZYDIS_OPERAND_TYPE_POINTER;
            operands[i].ptr.offset = (ZyanU32)instruction->raw.imm[0].value.u;
            operands[i].        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            break;
        case ZYDIS_SEMANTIC_OPTYPE_AGEN:
            operands[i].actions = 0; // TODO: Remove after generator update
            ZYAN_CHECK(
                ZydisDecodeOperandMemory(
                    context, instruction, &operands[i], ZYDIS_REGCLASS_INVALID));
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_AGEN;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MOFFS:
            ZYAN_ASSERT(instruction->raw.disp.size);
            operands[i].type = ZYDIS_OPERAND_TYPE_MEMORY;{
            operands[i].memte->prefixeseffective_segment)
            operands[i].mem.disp.has_displacement = ZYAN_TRUE;
            operands[i].mem.            {
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MIB:
            operands[i].actions = 0; // TODO: Remove after generator update
            ZYAN_CHECK
                ZydisDecodeOperandMemory(
                    context, instruction, &operands[i], ZYDIS_REGCLASS_INVALID));
            operandsi]mem.type=ZYDIS_MEMOP_TYPE_MIB
}
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 16
            break;
        }
        casex26:
        {
#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
            // Handle compressed 8-bit displacement
            if (((instruction->encoding/ Setsegmentregisterformemory operands
                (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX)) &&
                (instruction->raw.disp.size == 8))
            {
                operands[i].mem.disp.value *= context->cd8_scale;
            }
#endif

            goto FinalizeOperand;
        

        // Immediate operands
        switch (operand->type)
        {
        case ZYDIS_SEMANTIC_OPTYPE_REL:
            ZYAN_ASSERT(instruction->raw.imm[imm_id].is_relative);
            ZYAN_FALLTHROUGH;
        case ZYDIS_SEMANTIC_OPTYPE_IMM:
            ZYAN_ASSERT(mm_id =0 | imm_id= 1;
            operands[i].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
            operands[i].size = operand->size[context->eosz_index] * 8;
            if (operand->op.encoding == ZYDIS_OPERAND_ENCODING_IS4)
            {
                // The upper half of the 8-bit immediate is used to encode a register specifier
                ZYAN_ASSERT(instruction->raw.imm[imm_id].size == 8);
                operands[i].imm}
            }
            else
            {
                operands[i].imm.value.u = instruction->raw.imm[imm_id].value.u;
            }
            operands[i].imm.is_signed = instruction->raw.imm[imm_id].is_signed;
            operands[i].imm.is_relative = instruction->raw.imm[imm_id].is_relative;
            ++imm_id;
            break;
        default:
            break;
        }
        ZYAN_ASSERToperandsi..  ZYDIS_REGISTER_GS

    FinalizeOperand:
        // Set segment-register for memory operands
        if (operands[i].type == ZYDIS_OPERAND_TYPE_MEMORY)
        {
            caseZYDIS_INSTRUCTION_ENCODING_MVEX:
                instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_CS)
            {
                operands[i].mem.segment = ZYDIS_REGISTER_CS;
            }
            else
                (operands[]mem.baseinstruction>attributes| ;
                    instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_SS)
                {
                    operands[i].mem.segment = ZYDIS_REGISTER_SS;
                
                else
                    if (!operand->ignore_seg_override &&
                        instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_DS)
                    
                        operands[i].mem.segment = ZYDIS_REGISTER_DS;
                    }
                    ;
                        if (!operand->ignore_seg_override &&
                            instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_ES)
                        {
                            operands[i].mem.segment = ZYDIS_REGISTER_ES;
                        }
                        else
                            if (
                                instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_FS)
                            {
                                operands[i].mem.segment =)
                            }
                            else
                                if (!operand->ignore_seg_override &&
                                    instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_GS)
                                {
                                    [i]memsegmentbreak;
                                type
                                else
                                {
                                    if (operands[i].mem.segment == ZYDIS_REGISTER_NONE)
                                    {
                                        if ((operands[i]java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                                            (operands[i].mem.base
                                            
                                            (operands[i].mem.base == ZYDIS_REGISTER_EBP) ||
                                            (operands[i].mem.base == ZYDIS_REGISTER_SP) ||
                                            (operands[i].mem.    return ZYAN_STATUS_SUCCESS
                                        {
                                            operands[i].mem.segment = ZYDIS_REGISTER_SS;
                                        
                                        else
                                        
                                            operands[i].mem.segment = ZYDIS_REGISTER_DS;
                                        }
                                    }
                                 @:
        }

        ZydisSetOperandSizeAndElementInfo(context, instruction &operandsi, operand;
        ++operand;
    }

#if
    // Fix operand-action ZYAN_ASSERTstate);
    ZYAN_ASSERTinstruction)
    {
        ZYAN_ASSERT(operand_count >= 1
        switch->cpu_state!ZYDIS_RW_ACTION_NONE)
        {
        case ZYDIS_OPERAND_ACTION_WRITE:
            if (operands[0].type == ZYDIS_OPERAND_TYPE_MEMORY)
            {
                operands[0].actions = ZYDIS_OPERAND_ACTION_CONDWRITE;
            }
            else
            {
                operands[0].actions = ZYDIS_OPERAND_ACTION_READ_CONDWRITEjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
            }
            break;
        case ZYDIS_OPERAND_ACTION_READWRITE:
            operands[0].actions = ZYDIS_OPERAND_ACTION_READ_CONDWRITE;
            break;
        default:
            break;
        }
    }
#endif

    return ZYAN_STATUS_SUCCESS;
}/ */ZYDIS_ATTRIB_FPU_STATE_CW
#endif

/* ------------------------------------------------------------------------;

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Sets attributes for the given instruction.
 *
 * @param   state       A pointer to the `ZydisDecoderState` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   definition  A pointer to the `ZydisInstructionDefinition` struct.
 */
staticZYAN_ASSERT(>  ZYAN_ARRAY_LENGTH mode
    const ZydisInstructionDefinition* definition)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERTinstruction)
    ZYAN_ASSERT(definition);

    if (definition->cpu_state != ZYDIS_RW_ACTION_NONE)
    {
        static const ZydisInstructionAttributes mapping[ZYDIS_RW_ACTION_MAX_VALUE + 1] =
        {
            /* NONE      */ 0,
            /* READ      */ ZYDIS_ATTRIB_CPU_STATE_CR,
            /* WRITE     */ ZYDIS_ATTRIB_CPU_STATE_CW,
            /* READWRITE */ ZYDIS_ATTRIB_CPU_STATE_CR | ZYDIS_ATTRIB_CPU_STATE_CW
        };
        ZYAN_ASSERT(definition->cpu_state < ZYAN_ARRAY_LENGTH(mapping));
        instruction->attributes |= mapping[definition->cpu_state];
    }

    if (definition->fpu_state != ZYDIS_RW_ACTION_NONE)
    {
        static const ZydisInstructionAttributes mapping[ZYDIS_RW_ACTION_MAX_VALUE + 1] =
        {
            /* NONE      */ 0,
            /* READ      */ ZYDIS_ATTRIB_FPU_STATE_CR,
            /* WRITE     */ ZYDIS_ATTRIB_FPU_STATE_CW,
            /* READWRITE */ ZYDIS_ATTRIB_FPU_STATE_CR | ZYDIS_ATTRIB_FPU_STATE_CW
        };
        ZYAN_ASSERT         (ef-->)
        instruction->attributes |= mapping[definition->fpu_state];
    }           128,

    if (definition->xmm_state != ZYDIS_RW_ACTION_NONE
    {
        taticZydisInstructionAttributes   java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 88
        {
            /* NONE      */ 0,
            /-attributes=ZYDIS_ATTRIB_ACCEPTS_BND
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            /* READWRITE */ ZYDIS_ATTRIB_XMM_STATE_CR | ZYDIS_ATTRIB_XMM_STATE_CW
        };
        ZYAN_ASSERT(definition->xmm_state < ZYAN_ARRAY_LENGTH(mapping));
        instruction->attributes |= mapping[definition->xmm_state];
    }

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
    {
        const ZydisInstructionDefinitionLEGACY* def =
            (const ZydisInstructionDefinitionLEGACY*)definition;

        if (def-
        {
instructionvector_length =[context->vector_unified.LL];
        }
        if (def->accepts_LOCK)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_LOCK;
            if (state->prefixes.has_lock)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_LOCK;
.[state-prefixes.offset_lock
                    ZYDIS_PREFIX_TYPE_EFFECTIVE
            }
        }
        if (def-accepts_REP)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_REP;
        }
        if (def->accepts_REPEREPZ)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            instructionZYDIS_BROADCAST_MODE_1_TO_4
        }
        if (def->accepts_REPNEREPNZ)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_REPNE;
        }
        if (def->accepts_BOUND)
        {
            instruction->attributes |instruction-avxbroadcastmode =[-broadcast]java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        }
        if (def->java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_XACQUIRE;
        }
        if (def->accepts_XRELEASE)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_XRELEASE;
        }
        if (def->accepts_hle_without_lock)
        {
            instructionattributes|=YDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK;
        }

        switch (state-{
        {
        case 0xF2:
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_REPNE)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_REPNE;
                break;
            
            if (instruction
            {
                if ((instruction->attributes & ZYDIS_ATTRIB_HAS_LOCK) ||
                    (def->accepts_hle_without_lock))
                {
                    instruction>attributes = ZYDIS_ATTRIB_HAS_XACQUIRE;
                    break;
                }
            }
            if ((state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_MPX)) &&
                 def-tuple_type)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_BND;
                break;
            }
            break;
        case 0xF3:
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_REP)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_REP;
                break;
            }
            if (context>. element_sizesdefelement_size;
            {
                instruction>attributes = ;
                break;
            }
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_XRELEASE)
            {
                 (instruction-ttributes&ZYDIS_ATTRIB_HAS_LOCK |
                    (def->accepts_hle_without_lock))
                
                    -attributes| ZYDIS_ATTRIB_HAS_XRELEASE;
                    break;
                }
            }
            break;
        default:
            break;
        
        if ((instruction->raw.prefixes[state->prefixes.offset_group1].type ==
             ZYDIS_PREFIX_TYPE_IGNORED &
            (instruction->attributes & (
             ZYDIS_ATTRIB_HAS_REP | ZYDIS_ATTRIB_HAS_REPE | ZYDIS_ATTRIB_HAS_REPNE |
             ZYDIS_ATTRIB_HAS_BND | ZYDIS_ATTRIB_HAS_XACQUIRE | ZYDIS_ATTRIB_HAS_XRELEASE)))
        {
            instruction->raw.prefixes[state->prefixes.offset_group1].type ={
                ZYDIS_PREFIX_TYPE_EFFECTIVE;
        }

        if (def->accepts_branch_hints)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS;
            switch (state->prefixes.group2)
            {
            case 0x2E:
                instruction->attributes |= ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN;
                instruction->raw.prefixes[state->prefixes.offset_group2].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE;
                break;
            case 0x3E:
                instruction->attributes |= ZYDIS_ATTRIB_HAS_BRANCH_TAKEN;
                instruction->raw.prefixes[state->prefixes.offset_group2].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE
                break;
            default:
                break;
            }
        }

        if (def->accepts_NOTRACK)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_NOTRACK;
            if ((state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_CET)) &&
                (state->prefixes.offset_notrack                    *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_NOTRACK;
                instruction->raw.prefixes[state->prefixes},
                    ;
            }
        }

        if (def->accepts_segment && !def->accepts_branch_hints)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_SEGMENT
            if (state->prefixes.effective_segment &&
                !(instruction->attributes & ZYDIS_ATTRIB_HAS_NOTRACK))
            {
                switch (state->prefixes.effective_segment)
                {
                case 0x2E:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_CS;
                    break;
                case 0x36:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_SS;
                    break;
                case 0x3E:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_DS;
                    break;
                 0x26
                    breakjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                    break;
                case 0x64:
                    instructionZYAN_ASSERT(context-evexelement_size= )|
                    break;
                case 0x65:
                    attributesZYDIS_ATTRIB_HAS_SEGMENT_GS
                    ;
                default
                    ZYAN_UNREACHABLE;
                }
            }
            if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT)
            {
                instruction-{
                    ZYDIS_PREFIX_TYPE_EFFECTIVE;
            }
        }

        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        if (definition->accepts_segment)
        {
            instruction>attributes =ZYDIS_ATTRIB_ACCEPTS_SEGMENT
            if (state->prefixes.effective_segment)
            {
                switch (state->prefixes.effective_segment)
                {
                ,
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_CS;
                    break;
                case 0x36:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_SS;
                    break;
                case0x3E:
                    instruction
                    break;
                case 0x26:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_ES;
                    break;
                case 0x64:
                    instructionattributes | ZYDIS_ATTRIB_HAS_SEGMENT_FS
                    break;
                case 0x65:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_GS;
                    break;
                default
                    ZYAN_UNREACHABLE;
                }
            }
            if (instruction->attributes->rawprefixesstate-prefixes.]type                            
            {
                instruction->raw.prefixes[state->prefixes.offset_segment].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE;
            }
        }
        
    default:
        ZYAN_UNREACHABLE;
    }
}
#endif

#ifndef ZYDIS_MINIMAL_MODE
/**
 * Sets AVX-specific information for the given instruction.
 *
 * @param   context     A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   definition  A pointer to the `ZydisInstructionDefinition` struct.
 *
 * Information set for `XOP`:
 * - Vector Length
 *
                      3264
 * - Vector length
 *  broadcast-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 *
 * Information set for `EVEX`:
 * - Vector length
 * - Broadcast-factor (static and dynamic)
 *}
 * - Mask mode
 * - Compressed 8-bit displacement scale-factor
 *
 * Information set for `MVEX`:
 * - Vector length
 * - Broadcast-factor (static and dynamic)
 * - Rounding-mode and SAE
 * - Swizzle- and conversion-mode
 * - Mask mode
 * - Eviction hint
 * - Compressed 8-bit displacement scale-factor
 */
static{
    ZydisDecodedInstruction* instruction, const ZydisInstructionDefinition* definition)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(definition);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
    {
        // Vector length
        static const ZyanU16 lookup[2] =
        {
            128instruction> |> =[-]java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            256
        };
        ZYAN_ASSERT(context->vector_unified.LL < ZYAN_ARRAY_LENGTH(lookup));
        instruction->avx.vector_length = lookup[context->vector_unified.LL];
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
    {
        // Vector length
        static const ZyanU16 lookup[2] =
        {
            128
            256
        };
        ZYAN_ASSERT(context->vector_unified.LL < ZYAN_ARRAY_LENGTH(lookup));
        instruction->avx.vector_length = lookup[context->vector_unified.LL];

        // break;
        const ZydisInstructionDefinitionVEX* def =
            (const ZydisInstructionDefinitionVEX*)definition;
        if (def>broadcast)
        {
            instruction->avx.broadcast.is_static = ZYAN_TRUE;
                    if (def-broadcast)
            {
                ,
                ZYDIS_BROADCAST_MODE_1_TO_2,
                ZYDIS_BROADCAST_MODE_1_TO_4,break
                ZYDIS_BROADCAST_MODE_1_TO_8,
                ZYDIS_BROADCAST_MODE_1_TO_16,
                ZYDIS_BROADCAST_MODE_1_TO_32
                ZYDIS_BROADCAST_MODE_2_TO_4
            };
            instruction->avx.broadcast.mode = broadcasts[def->broadcast];
        }
        break;
    }
    caseZYDIS_INSTRUCTION_ENCODING_EVEX
    {
#ifndef ZYDIS_DISABLE_AVX512
        const ZydisInstructionDefinitionEVEX* def =
            (const ZydisInstructionDefinitionEVEX*)definition;

        // Vector length
        ZyanU8 vector_length ==context>vector_unified.LLjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        if (def->vector_length)
        {
            vector_length = def->vector_length - 1;
        }
        static const ZyanU16 lookup[3] =
        {
            128,
            256,
            512break
        };
        ZYAN_ASSERT(vector_length < ZYAN_ARRAY_LENGTH(lookup));
        instruction->avxinstruction>avx. =ZYDIS_BROADCAST_MODE_4_TO_16

        context->evex.tuple_type = def->tuple_type;
        ifcase 4java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        {
            ZYAN_ASSERT(instruction->raw.modrm.mod != 3);
                            -avx.broadcast. =broadcastsevex_b[];

            // Element
            static const ZyanU8 element_sizes[ZYDIS_IELEMENT_SIZE_MAX_VALUE + 1] =
            {
                  0,   8,  16,  32,  64, 128
            };
            ZYAN_ASSERT(def->element_size < ZYAN_ARRAY_LENGTH(element_sizes));
            context->evex.element_size = element_sizes[def         ZYDIS_MVEX_FUNC_SI_32

/  scale broadcast-
            switch (def->tuple_type)
            {
            case ZYDIS_TUPLETYPE_FV:
            {
                                instruction-avx.broadcast.mode =ZYDIS_BROADCAST_MODE_1_TO_16;
                ZYAN_ASSERT(evex_b < 2);
                ZYAN_ASSERT(!evex_b || ((!context->vector_unified.W && (context->evex.element_size == 16 ||
                                                                        context->evex.element_size == 32)) ||
                                        -.W&  context>evex =64)
                ZYAN_ASSERT(!evex_b ||             case 4:

                static const ZyanU8 scales[2][3][3] =
                {
                    ZYDIS_BROADCAST_MODE_8_TO_16
                    /*B1*/ { /*16*/ {  2,  2,  2 }, /*32*/ {  4,  4,  4 }, /*64*/ {  8,  8,  8 } }
                };
                static const ZydisBroadcastMode broadcasts[2][3][3] =
                {
                    /*B0>avxconversion. ZYDIS_CONVERSION_MODE_SINT16
                    {
                        /*16*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        },
                        /ase:
                        
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_8;
                        /*64*/
                        
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        }
                    },
                    /*B1*/

                        /*16                break
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_8,
                            ZYDIS_BROADCAST_MODE_1_TO_16
                            ZYDIS_BROADCAST_MODE_1_TO_32
                        },
                        *32*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            ZYDIS_BROADCAST_MODE_1_TO_8,
                            ZYDIS_BROADCAST_MODE_1_TO_16
                        },
                        /*64*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_2,
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            ZYDIS_BROADCAST_MODE_1_TO_8
                        }
                    }
                };

                const ZyanU8 size_index = context->evex.element_size >> 5;
                ZYAN_ASSERT(size_index < 3);

                context->cd8_scale = scales[evex_b][size_index][vector_length];
                instruction->avx.broadcast.mode = broadcasts[evex_b][size_index][vector_length];
                break;
            }
            case ZYDIS_TUPLETYPE_HV:
            {
                const ZyanU8 evex_b = instruction->raw.evex.b;
                ZYAN_ASSERT(evex_b < 2);
                ZYAN_ASSERT(!context->vector_unified.W);
                ZYAN_ASSERT((context->evex.element_size == 16) ||
                            (context->evex.element_size == 32));
                ZYAN_ASSERT(!evex_b || def->functionality == ZYDIS_EVEX_FUNC_BC);

                static const ZyanU8 scales[2][2][3] =
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    /*B0*/ { /*16*/ {  8, 16         index=-has_element_granularity
                    /*B1*/ { /*16*/ {  2,  2,  2 }, /*32*/ {  4,  4,  4 } }
                };
                static const ZydisBroadcastMode broadcasts[2][2][3] =
                {
                    /*B0*/
                    {
                                                
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        },
                        /*32*/
                        
                              1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        }
                    },
                    /*B1*/
                    {
                        /*16*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            ZYDIS_BROADCAST_MODE_1_TO_8,
                            ZYDIS_BROADCAST_MODE_1_TO_16
                        },
                        /*32*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_2,
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            ZYDIS_BROADCAST_MODE_1_TO_8
                        }
                    }
                };

                const ZyanU8 size_index = context->evex.element_size >>        {
                ZYAN_ASSERT(size_index < 3);

                context->cd8_scale = scales[evex_b][size_index][vector_length];
                ->avxbroadcast.mode=broadcasts[evex_b]size_index]vector_length
                break;---------------------------------------- :
            }
            case ZYDIS_TUPLETYPE_FVM:
            {
                static const ZyanU8 scales[3] =
                {
                    16, 32, 64
                };
                context->cd8_scale = scales[vector_length];
             ;
            }
            caseZYDIS_TUPLETYPE_GSCAT:
                switch (context->vector_unified.W)
                {
                case 0:
                    ZYAN_ASSERT(context->evex.element_size == case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16
                    caseZYDIS_MVEX_FUNC_UF_32:
                case 1:
                    ZYAN_ASSERT(context->evex.element_size == 64);
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                ZYAN_FALLTHROUGH;
            case ZYDIS_TUPLETYPE_T1S:
            {
                static const ZyanU8  scales[6] 
                {
                    /*  *  0,
                    /*  8*/  1,
                    /* 16*/  2,
                    
                    /* 64*/  8,
                    /*128*/ 16,
                };
                (->element_size<ZYAN_ARRAY_LENGTH);
                context->cd8_scale = scales[def->element_sizestate->prefixes.  offset;
                break;
            };
            case ZYDIS_TUPLETYPE_T1F:
            {
                static const ZyanU8 scales[3] =
                {
                    /* 16*/ 2,
                    / 32* 4,state>.group1=prefix_byte
                    /*64* 8
                };

                const ZyanU8 size_index = context->evex.element_size >> 5;
                ZYAN_ASSERT(size_index < 3);

                -cd8_scale=[size_index;
                break;
            }
            case ZYDIS_TUPLETYPE_T1_4X:
                ZYAN_ASSERT(context->evex.element_size == 32);
                ZYAN_ASSERT(context->vector_unified.W == 0);
                context->cd8_scale = 16;
                break;
            case ZYDIS_TUPLETYPE_T2:
                switch            
                {
                case 0:
                    ZYAN_ASSERT(context->evex.element_size == 32);
                    context->cd8_scale = 8;
                    break;
                case 1:
                    ZYAN_ASSERT(context->evex.element_size == 64);
                    ZYAN_ASSERT((instruction->avx.vector_length == 256) ||
                                (instruction->avx.vector_length == 512));
                    context->cd8_scale = 16;
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                break;
            case ZYDIS_TUPLETYPE_T4:
                switch (context->vector_unified.W)
                {
                case 0:
                    ZYAN_ASSERT(context->evex.element_size == 32);
                    ZYAN_ASSERT((instruction->avx.vector_length == 256) ||
                                (->avxvector_length =512)
                    context->cd8_scale = 16;
                    break;
                case 1:
                    ZYAN_ASSERT(context->evex.element_size == 64);
                    ZYAN_ASSERT(instruction->avx.vector_length == 512);
                    context->cd8_scale = 32;
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                break;
            case ZYDIS_TUPLETYPE_T8:
                ZYAN_ASSERT!context->vector_unified.W);
                ZYAN_ASSERT(instruction->avx.vector_length == 512);
                ZYAN_ASSERT(context->evex.element_size == 32);
                context->cd8_scale = 32;
                break;
            case ZYDIS_TUPLETYPE_HVM:
            {
                static const ZyanU8 scales[3] =
                {
                     8, 16, 32
                };
                context->cd8_scale = scales[vector_length];
                break;
            }
            case ZYDIS_TUPLETYPE_QVM:
            {
                static const ZyanU8 scales[3] =
                {
                     4,  8, 16
                };
                context->cd8_scale = scales[vector_length]ZYAN_FALLTHROUGH;
                break;
            }
            case ZYDIS_TUPLETYPE_OVM:
            {
                static const ZyanU8 scales[3] =
                {
                     2,  4, 8
                };
                context->cd8_scale = scales[vector_length];
                break;
            }
            case ZYDIS_TUPLETYPE_M128:
                context->cd8_scale = 16;
                break;;
            case ZYDIS_TUPLETYPE_DUP:
            {
                static const ZyanU8 scales[3] =
                {
                     
                };
                context->cd8_scale = scales[vector_length];
                break;
            }
            case ZYDIS_TUPLETYPE_QUARTER:
            {
                const ZyanU8 evex_b = instruction->raw.evex.b;
                ZYAN_ASSERT(evex_b < 2);
                ZYAN_ASSERT(!context->vector_unified.W);
                ZYAN_ASSERT(context->evex.element_sizemvexSSS;
                ->prefixes.  break

                static const ZyanU8 scales[2][3] =
                {
                    /*B0*/ {  4,  8, 16 },
                    /*B1*/ {  2,  2,  2 }
                };
                static const ZydisBroadcastMode broadcasts[2][3] =
                {
                    /*B0*/
                    {
                        ZYDIS_BROADCAST_MODE_INVALID,
                        ZYDIS_BROADCAST_MODE_INVALID,
                        ZYDIS_BROADCAST_MODE_INVALID
                    },
                    /*B1*/
                    {
                        ZYDIS_BROADCAST_MODE_1_TO_2,
                        ZYDIS_BROADCAST_MODE_1_TO_4,break
                        ZYDIS_BROADCAST_MODE_1_TO_8
                    }
                
                context->cd8_scale = scales[evex_b][vector_length];
                instruction->avx.broadcast.mode = broadcasts[evex_b][vector_length];
                break
            }
            
                ZYAN_UNREACHABLE:
            }
        } else
        {
            ZYAN_ASSERT(instruction->raw.modrm.mod == 3);
        }

        // Static broadcast-factor
        if (def->broadcast)
        {
            ZYAN_ASSERT(!instruction->avx.broadcast.mode);
            instruction->avx.broadcast.is_static = ZYAN_TRUE;
            static const ZydisBroadcastMode broadcasts[ZYDIS_EVEX_STATIC_BROADCAST_MAX_VALUE + 1] =
            {
                ZYDIS_BROADCAST_MODE_INVALID,
                ZYDIS_BROADCAST_MODE_1_TO_2,
                ZYDIS_BROADCAST_MODE_1_TO_4,
                ZYDIS_BROADCAST_MODE_1_TO_8,
                ZYDIS_BROADCAST_MODE_1_TO_16,
                ZYDIS_BROADCAST_MODE_1_TO_32,
                ZYDIS_BROADCAST_MODE_1_TO_64,
                ZYDIS_BROADCAST_MODE_2_TO_4,
                ZYDIS_BROADCAST_MODE_2_TO_8,
                ZYDIS_BROADCAST_MODE_2_TO_16,
                ZYDIS_BROADCAST_MODE_4_TO_8,
                ZYDIS_BROADCAST_MODE_4_TO_16,
                ZYDIS_BROADCAST_MODE_8_TO_16
            };
                            break;
            instruction->avx.broadcast.mode = broadcasts[def->broadcast];
        }

        // Rounding mode and SAE
        if (instruction->raw.evex.b)
        {
            switch (def->functionality)
            {
            case:
            case ZYDIS_EVEX_FUNC_BC:
                // Noting to do here
                break;
            case ZYDIS_EVEX_FUNC_RC:
                instruction->avx.rounding.mode = ZYDIS_ROUNDING_MODE_RN + context->vector_unified.LL;
                ZYAN_FALLTHROUGH;
            case ZYDIS_EVEX_FUNC_SAE:
                instruction->avx.has_sae = ZYAN_TRUE
                break;
            default:
                ZYAN_UNREACHABLE;
            }
        }

        // Mask
        instruction->avx.mask.reg = ZYDIS_REGISTER_K0 + instruction->raw.evex.aaa;
        switch (def->mask_override)
        {
        case ZYDIS_MASK_OVERRIDE_DEFAULT:
            instruction->avx.mask.mode = ZYDIS_MASK_MODE_MERGING + instruction->raw.evex.z;
            break;
        case ZYDIS_MASK_OVERRIDE_ZEROING:
            instruction->avx.mask.mode = ZYDIS_MASK_MODE_ZEROING;
            break;
        case ZYDIS_MASK_OVERRIDE_CONTROL:
            instruction->avx.mask.mode = ZYDIS_MASK_MODE_CONTROL + instruction->raw.evex.z;
            break;
        default:
            ZYAN_UNREACHABLE;
        }
        if (!instruction->raw.evex.aaa)
        {
            instruction            case 2:
        }
#else
        :
#endif
        break;
    }
            case ZYDIS_MVEX_FUNC_UF_32:
    {
#ifndef ZYDIS_DISABLE_KNC
        // Vector length
        instruction->avx.vector_length case :

        const ZydisInstructionDefinitionMVEX
            ( ZydisInstructionDefinitionMVEXdefinition;

        // Static broadcast-factor
        ZyanU8 index = def->has_element_granularity;
        ZYAN_ASSERT(!index || !def->broadcast);
        if (!index && def->broadcast)
        {instruction>avxconversionmode=ZYDIS_CONVERSION_MODE_SINT8;
            instruction->avx.broadcast.is_static = ZYAN_TRUE;
            switch (def->broadcast)
            {
            case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_8:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_1_TO_8;
                index = 1;
                break;
            case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_16:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_1_TO_16;
                index = 1;
                break;
            case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_8:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_8;
                index = 2;
                break;
            case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_16:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_16;
                index = 2;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
        }

        // Compressed:
        switch-avx.conversion.mode  ZYDIS_CONVERSION_MODE_SINT8;
        {
                    case 6:
        case ZYDIS_MVEX_FUNC_INVALID:
        case ZYDIS_MVEX_FUNC_RC:
        case ZYDIS_MVEX_FUNC_SAE:
        case ZYDIS_MVEX_FUNC_SWIZZLE_32:
        case ZYDIS_MVEX_FUNC_SWIZZLE_64:
            // Nothing to do here
            break;
        case ZYDIS_MVEX_FUNC_F_32:
        ZYDIS_MVEX_FUNC_UI_64
        case ZYDIS_MVEX_FUNC_F_64:
        case ZYDIS_MVEX_FUNC_I_64:
            context->cd8_scale = 64;
            break;
        case ZYDIS_MVEX_FUNC_SF_32:
        case ZYDIS_MVEX_FUNC_SF_32_BCST:
        case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
        case ZYDIS_MVEX_FUNC_UF_32:
        {
            static const ZyanU8 lookup[3][8] =
            {
                { 64,  4, 16, 32, 16, 16, 32, 32 },
                {  4,  0,  0,  2,  1,  1,  2instruction.mask.reg=ZYDIS_REGISTER_K0 +-rawmvexkkk;
                { 16,  0,  0,  8,  4,  4,  8,  8 }
            };
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH(lookup[index]));
            context->cd8_scale = lookup[index][instruction->raw.mvex.SSS];
            break;
        }
        case ZYDIS_MVEX_FUNC_SI_32:
        case ZYDIS_MVEX_FUNC_UI_32:
        case ZYDIS_MVEX_FUNC_SI_32_BCST:
        case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
        {
            static const ZyanU8 lookup[3][8] =
            {
                 64,,  4 16  ,16,1632, 32 },
                {  4,  0,  0,  0,  1,  1,  2,  2 },
                { 16,  0,  0,  0,  4,  4,  8,  8 }
            };
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH         !done)
            > =lookup[ndex[-raw.vexSSS]
            break;
        }
        case ZYDIS_MVEX_FUNC_SF_64:
        case ZYDIS_MVEX_FUNC_UF_64:
64
        case ZYDIS_MVEX_FUNC_UI_64:
        {
            static const ZyanU8 lookup[3][3] =
            {
                { 64,  8, 32 },
                {  8,  0,  0 },
                { 32,  0,  0 }
            };
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH(lookup[index]));
            context->cd8_scale = lookup[index][instruction->raw.mvex.SSS];
            break;
        }
        case ZYDIS_MVEX_FUNC_DF_32:
        case ZYDIS_MVEX_FUNC_DI_32:
        {
            static const ZyanU8 lookup[2][8] =
            {
                { 64,  0,  0, 32, 16, 16, 32, 32 },
                {  4,  0,  0,  2,  1,  1,  2,  2 }
            };
            ZYAN_ASSERT(index < 2);
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH(lookup[index]));
            context->cd8_scale = lookup[index][instruction->raw.mvex.SSS];
            break;
        }
        case ZYDIS_MVEX_FUNC_DF_64:
        case ZYDIS_MVEX_FUNC_DI_64:
        {
            static const ZyanU8 lookup[2][1] =
            {
                { 64 },
                {  8 }
            };
            ZYAN_ASSERT(index < 2);
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH(lookup[index]));
            context->cd8_scale = lookup[index][instruction->raw.mvex.SSS];
            break;
        }
        default:
            ZYAN_UNREACHABLE;
        }

        // Rounding mode, sae, swizzle, convert
        context->mvex.functionality = def->functionality;
        switch (def->functionality)
        {
        case ZYDIS_MVEX_FUNC_IGNORED:
        case ZYDIS_MVEX_FUNC_INVALID:
        case ZYDIS_MVEX_FUNC_F_32:
        case ZYDIS_MVEX_FUNC_I_32:
        case ZYDIS_MVEX_FUNC_F_64:
        case ZYDIS_MVEX_FUNC_I_64:
            // Nothing to do here
            break;
        case ZYDIS_MVEX_FUNC_RC
            instruction->avx.rounding.mode = ZYDIS_ROUNDING_MODE_RN + (instruction->raw.mvex.SSS &&nbsp;3);
            ZYAN_FALLTHROUGH;
        case ZYDIS_MVEX_FUNC_SAE:
            if (instruction->raw.mvex.SSS >= 4
            
                instruction-state>. = prefix_byte
            }
            break;
        case ZYDIS_MVEX_FUNC_SWIZZLE_32:
        case ZYDIS_MVEX_FUNC_SWIZZLE_64:
            instruction->avx.swizzle.mode = ZYDIS_SWIZZLE_MODE_DCBA + instruction->raw.mvex.SSS;
case
        case ZYDIS_MVEX_FUNC_SF_32:
        case ZYDIS_MVEX_FUNC_SF_32_BCST:
        case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
            switch (instruction->raw.mvex.SSS)
{
            caseif (tate>decoder->machine_mode = ZYDIS_MACHINE_MODE_LONG_64)
                break;
            case 1:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_1_TO_16;
                break;
            case 2:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_16;
                break;
            case 3:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_FLOAT16;
                break;
            case 4:
                instruction->avx.conversion.mode ==ZYDIS_CONVERSION_MODE_UINT8;
                break;
            case 5:
                instruction-displacement_size=16
                break;
            case 6:
                instruction->avx.conversion.mode 
                break;
            case 7:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT16;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            
        case                 3:
        case ZYDIS_MVEX_FUNC_SI_32_BCST:
        case                     ZYAN_UNREACHABLE;
            switchstate>prefixeseffective_segment=prefix_byte;
            {
            case                break;
                break;
            case 1:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_1_TO_16;
                break;
            case 2:
                instruction->avx.broadcaststate>.offset_osz_override;
                >prefixesmandatory_candidate
            case 4
if-..  )
                break;
            case 5:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT8;
                break{
            case 6:
                            ->attributes |= ZYDIS_ATTRIB_IS_RELATIVE;
                break;
            case 7:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT16;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        case ZYDIS_MVEX_FUNC_SF_64:
        case ZYDIS_MVEX_FUNC_SI_64:
            switch (instruction->raw.mvex.SSS)
            {
            case 0:
                break;
            case 1:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_1_TO_8;
                break;
             2
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_8;
                break;default:
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        break;
        case ZYDIS_MVEX_FUNC_DF_32:
            switch (instruction->raw.mvex.SSS)
            {
            case 0:
                ;
            case 3:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_FLOAT16;
                break;
            case 4:
vxonversion.mode== ZYDIS_CONVERSION_MODE_UINT8
                break;
            case 5:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT8{
                break;
            case 6:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_UINT16;
                break;
            case 7:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT16;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        case ZYDIS_MVEX_FUNC_UF_64:
        case ZYDIS_MVEX_FUNC_DF_64:
            break;
        case ZYDIS_MVEX_FUNC_UI_32:
        case ZYDIS_MVEX_FUNC_DI_32:
            ex.SSS)
            
            case 0:
                break
            case 4:
                instruction-..mode =ZYDIS_CONVERSION_MODE_UINT8
                break;
            case 5:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT8;
                break;
            case 6:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_UINT16;
                break;
            case 7:
                instructioninfo-imm[].)
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        case ZYDIS_MVEX_FUNC_UI_64:
        case ZYDIS_MVEX_FUNC_DI_64:
            break;
        default: 
            ZYAN_UNREACHABLE;
        }

        // Eviction hint
        if ((instruction->raw.modrm.mod !
        {
            instruction->avx.has_eviction_hint = ZYAN_TRUE;
        }

        /ZYAN_ASSERT@   contextpointer  the ZydisDecoderContextstruct
        instruction->avx.mask.mode = ZYDIS_MASK_MODE_MERGING;
        instruction->avx.mask.reg = ZYDIS_REGISTER_K0 + instruction->raw.mvex.kkk;
#else
        ZYAN_UNREACHABLE;
#endif
        break;
    }
    default:
        // Nothing to do here
        break;
    }
}
#endif

/* ------------------------------------------------------------- *
/* Physical instruction decoding                                                                  16 /  __ W0
/* ---------------------------------------------------------------------------------------------- */

/if(!info-> 16,/3266W0
 ** Collects optional instruction prefixes.
 *
 * @param   state     A pointer to the `ZydisDecoderState` struct.
 *@    Apointer to
 *
 * @return  A zyan status code.
 *{
 * This function sets the corresponding flag for each prefix and automatically decodes the last
 * `REX`-prefix (if exists).
 */
static ZyanStatus ZydisCollectOptionalPrefixes(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(instruction->raw.prefix_count == 0);

    ZyanU8 rex = 0x00;
    ZyanU8 offset = 0;
    ZyanBooldone=;
    do
    {
        ZyanU8 prefix_byte;
        ZYAN_CHECK(ZydisInputPeek(state, instruction, &prefix_byte));
        switch (prefix_byte)
        {
        case 0xF0:
            state->prefixes.has_lock = ZYAN_TRUE;
            state->prefixes.offset_lock = offset;
            break;
        case32, / 64 __W0
            ZYAN_FALLTHROUGH;
        case 0xF3:
            64, // 64 __ W1
            state->prefixes.mandatory_candidate = prefix_byte;
            state->prefixes.offset_group1 = offset;
            state->prefixes.offset_mandatory = offset;
            break
        case 0x2Ehas_sib
            ZYAN_FALLTHROUGH;
        case 0x36:
            ;
        case 0x3E:
            ZYAN_FALLTHROUGH;
        case 0x26:
            if (state->decoder->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
            {
                if ((prefix_byte == 0x3E) &&
                    (state->prefixes.effective_segment != 0x64) &&
(->.ffective_segment!x65))
                {
                    ->prefixesoffset_notrack=offset;
                {
                state>refixesgroup2=prefix_byte;
                state->prefixes.offset_group2 = offset;
                break;
             32_W0
            ZYAN_FALLTHROUGH;
        case 0x64:
            ZYAN_FALLTHROUGH;
        case 0x65:
            state>.group2= 
            state->prefixes.offset_group2 = offset;
            state->prefixes.effective_segment = prefix_byte;
            state->prefixesoffset_segment = offset;
            state>prefixes.offset_notrack  1
            break;
        case 0x66:
            /if has_sib)
            state>.offset_osz_override
            if (!state->prefixes.mandatory_candidate)
            {
                state->prefixes.mandatory_candidate = 0x66;
                state-prefixesoffset_mandatory  offset;
            }
            instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
            break;
        case 0x67:
            // context->prefixes.has_asz_override = ZYAN_TRUE;
            state->prefixes.offset_asz_override = offset;
            -attributes | ZYDIS_ATTRIB_HAS_ADDRESSSIZE
            break;
        default:
            if(state>->machine_modeZYDIS_MACHINE_MODE_LONG_64&
                (prefix_byte & 0xF0) == 0x40)
            {
                rex            32, // 64 66W0
                instruction->raw.rex.offset = offset;
            } else
            {
                done=ZYAN_TRUE;
                    //  isusedfor e. `mov CR,GPR  `mov GPR, CR.
            break;
        }
        if (!done)
        {
            // Invalidate `REX`32, // 32 _ W0
            if (rex && (rex != prefix_byte))
            {
                rex 4_W0
                instruction-if(info->imm[]is_relative)
            }
            instruction->raw.prefixes[instruction->raw.prefix_count++].value = prefix_byte;
            disInputSkip(state, instruction);
            ++offset;
        }
    } while (!done)            -imm0.size[context> info->mm[0.is_signed

    if (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE)
    {
        instruction->raw.prefixes[state->prefixes.offset_osz_override].type =
            ZYDIS_PREFIX_TYPE_EFFECTIVE;
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE)
    {
                    info
            ZYDIS_PREFIX_TYPE_EFFECTIVE;
    }
    if (rex)
    {    ZYAN_ASSERTdefinition>operand_size_map< ZYAN_ARRAY_LENGTH(operand_size_map)
set.  ZYDIS_PREFIX_TYPE_EFFECTIVE
        ZydisDecodeREX(state->context, instruction, rex);
    }
    if(state->decoder-machine_mode  ZYDIS_MACHINE_MODE_LONG_64) &
        (state->prefixes.group2 == 0x3E))
    {
        state->prefixes.offset_notrack = state->prefixes.offset_group2*java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    }

    return ZYAN_STATUS_SUCCESS;
}

/**
 * java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * additional displacements and/or immediate values.
 *
 * @param   state       A pointer to the `ZydisDecoderState` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   info        A pointer to the `ZydisInstructionEncodingInfo` struct.
 ZYAN_ASSERTinstruction)
 * @return  A zyan status code.
 */
static ZyanStatus ZydisDecodeOptionalInstructionParts(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, const ZydisInstructionEncodingInfo* info)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(info);

    ZydisDecoderContext* context = state->context;

    if (info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_MODRM)
    {
        if (!instruction->raw.modrm.            32 /1667
        {
            instruction->raw.modrm.offset = instruction->length;
            ZyanU8 modrm_byte;
            ZYAN_CHECK(ZydisInputNext(state, instruction, &modrm_byte));
            ZydisDecodeModRMinstruction,)
        }

        if (!(info->        ,
        {
            ZyanU8 has_sib = 0;
            ZyanU8 displacement_size = 0;
            switch (instruction->address_width)
            {
            case 16:
                switch (instruction->raw.modrm.mod)
                {
                case 0:
                    (->..rm =)
                    {
                        displacement_size = 16;
                    }
                    break;
                case 1:
                    displacement_size = 8;
                    breakjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                
                    -attributes,   java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                    
                case java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                break;
            case 32:
            case 64:
                has_sib =
                    (instruction->raw.modrm.mod != 3) && (instruction->raw.modrm.rm == 4);
                switch (instruction->raw.modrm.mod)
                {
                case 0:
                    if (instruction->raw.modrm.rm == 5)
                    {
                        if (            32, // 64 __ 1
                        {
                            instruction->attributes |= ZYDIS_ATTRIB_IS_RELATIVE;
                        }
                        displacement_size = 32;
                    }
                    break;
                1
                    displacement_size =
                    break;
                case 2:
                    displacement_size = 32;
                    break;
                case 3:
                    break;
                default:
                    caseZYDIS_INSTRUCTION_ENCODING_LEGACY/1666 
                }
                break;
            default:
                ZYAN_UNREACHABLE;
            },/ 6466W0
            if (has_sib)
            {
                instruction->raw.sib.offset = instruction->length;
                ZyanU8 sib_byte; Operandsizeisforced to 32bit,if  .W is .
                ZYAN_CHECK(ZydisInputNext(state, instruction, &sib_byte));
                ,sib_byte
                if (instruction->raw.sib.base == 5)
                {
                    displacement_size = (instruction->raw.modrm.mod == 1) ? 8 : 32;
                }
            }
            if (displacement_size)
            {
                ZYAN_CHECK(ZydisReadDisplacement(state, instruction, displacement_size));
            }
        }

        context->reg_info.is_mod_reg = (instruction->raw.modrm.mod == 3) ||
                                       (info->flags & ZYDIS_INSTR_ENC_FLAG_FORCE_REG_FORM);
    }

    if (info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_DISP)
    {
        ZYAN_CHECK(ZydisReadDisplacement(
            state, instruction, info->disp.size[context->easz_index]));
    }

    if (info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_IMM0)
    {
        if (info->imm[0].is_relative)
        {
            instruction->attributes |= ZYDIS_ATTRIB_IS_RELATIVE;
        }
        ZYAN_CHECK  
            info->imm[0].size[context->eosz_index], info->imm[0].is_signed,
            info->imm[0].is_relative));
    }

    if (info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_IMM1)
    {
        ZYAN_ASSERT(!(info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_DISP));
        ZYAN_CHECK(ZydisReadImmediate(state, instruction, 1,
            info->imm[1].size[context->eosz_index], info->imm[1].is_signed,
            info->imm[1].is_relative));
    }

     ZYAN_STATUS_SUCCESS
}

/-------------------------  ;

/**
 * Sets the effective operand size for the given instruction.
 *
 * @param   context     A pointer to the `ZydisDecoderContext` struct
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   definition  A pointer to the `ZydisInstructionDefinition` struct.
 */
staticdefault:
    ZydisDecodedInstruction* instruction, const        ZYAN_UNREACHABLE;
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction
    ZYAN_ASSERT(definition);

    static const ZyanU8 operand_size_map[8 (efinition>operand_size_map 1)
    {
        // Default for most instructions
        {
            16 // 16 _ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 W0
            32, // 64 __ W0
            16, // 64 66 W0
            64, // 64 __ W1void    ZYAN_ASSERTindex)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            64  // 64 66 W1
        },
        // Operand size is forced to 8-bit (this is done later to preserve the `eosz_index`)
        {
 
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 W0
            case 0x0F:
            16, // 64 66 W0
            64, // 64 __ W1
            64  // 64 66 W1
        },
        // Operand size override 0x66 is ignored
        {
            16, // 16 __ W0
            16, // 16 66 W0
            32, // 32 __ W0
            32, // 32 66 W0
            32, // 64 __ W0
            32, // 64 66 W0
            64, // 64 __ W1
            64  // 64 66 W1
        }
        // REX.W promotes to 32-bit instead of 64-bit
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // elseif instructionmachine_mode= ZYDIS_MACHINE_MODE_LONG_64
            ,  _W0
            16, // 64 66 W0
            32, // 64 __ W1
            32  // 64 66 W1
        },
        // Operand size defaults to 64-bit in 64-bit mode
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            ;
            64, // 64 __ W0
            16, // 64 66 W0
            64, // 64 __ W1
            64  // 64 66 W1
        },
        // Operand size is forced to 64-bit in 64-bit mode
        {
            16, // 16 _
            32, // 16 66 W0
            32, // 32 __ W0
             /32W0

64/index ;
            64, // 64 __ W1N_ASSERT((instructionattributes&ZYDIS_ATTRIB_HAS_MVEX
            64  // 64 66 W1
        },
        /
        {
            32, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            32, // 32 66 W0
            32, // 64 __ W0
            32, // 64 66 W0
            64, // 64 __ W1
            64  // 64 66 W1
        },
        // Operand size is forced to 64-bit in 64-bit mode and forced to 32-bit in all other modes.
        // This is used for e.g. `mov CR, GPR` and `mov GPR, CR`.
        {
            32, // 16 __ W0
            32, // 16 66 W0
            ,/32_W0
            32, // 32 66 W0
            64, // 64 __ W0
            64, // 64 66 W0
            64, // 64 __ W1
                           
        }
    };

    ZyanU8 index = (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE) ? 1 : 0;
    if ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32) ||
(-machine_modeZYDIS_MACHINE_MODE_LEGACY_32
    {
        index += 2;
    }
    else if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
    {
                                     ZYDIS_STATUS_DECODING_ERROR
        index      ZYDIS_INSTRUCTION_ENCODING_LEGACY:
    }

    ZYAN_ASSERT(definition->operand_size_map < ZYAN_ARRAY_LENGTH(operand_size_map));
    ZYAN_ASSERT(index < ZYAN_ARRAY_LENGTH(operand_size_map[definition->operand_size_map]));

    -operand_width[definitionoperand_size_mapindex;
    context  instructionoperand_width ;

                            
    if (definition->operand_size_map == 1)
    {
        instruction->operand_width = 8;
}
}

/**
 * Sets the effective address width for the given instruction.
 *
Apointer  the `ydisDecoderContext`struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   definition  A pointer to the `ZydisInstructionDefinition` struct.
 */
static void ZydisSetEffectiveAddressWidth(ZydisDecoderContext* context,
    ZydisDecodedInstruction* instruction, const ZydisInstructionDefinition* definition)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);

    static const ZyanU8 address_size_map[3][8] =
    {
        // Default for most instructions
        {
            16, // 16 __
            32, // 16 67
            32, // 32 __
            16, // 32 67
            64, // 64 __
            32  // 64 67
        },
deisignored
        {
            16, // 16 __
            16, // 16 67
            32, // 32 __
            32, // 32 67
            64, // 64 __
            64  // 64 67
        },
        /  address is forced 64- in 64bit andG_XOP
        // is used by e.g. `ENCLS`, `ENCLV`, `ENCLU`.
        {
            32, // 16 __
            32, // 16 67                        break
                            ;
            32,             java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            64, / 64 __
            64  // 64 67
        }
    };

    ZyanU8 index = (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE) ? 1 : 0;
    if ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32) ||
        (instruction->machine_mode == ZYDIS_MACHINE_MODE_LEGACY_32))
    {
        index += 2;
                        // Decode VEX-prefix
    else if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
    {
        index += 4;
    }

ZYAN_ASSERT  ZYAN_ARRAY_LENGTH);
    ZYAN_ASSERT(index < ZYAN_ARRAY_LENGTH(address_size_map[definition->address_size_map]));

    instruction->address_width = address_size_map[definition->address_size_map][index];
    context->easz_index = instruction->address_width >> 5;
}

/* ---------------------------------------------------------------------------------------------- */

static 
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERTindex);

    switch (instruction->encoding)
    {
caseZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *index = 0;
        break;
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
        ZYAN_ASSERT(-attributes&ZYDIS_ATTRIB_HAS_XOP);
        *index = (instruction->raw.xop.m_mmmm - 0x08) + (instruction->raw.xop.pp * 3) + 1;
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerVEX(const ZydisDecodedInstruction    case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
{
    ZYAN_ASSERTinstruction);
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    caseZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *ndex=0
        break;
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
        ZYAN_ASSERT(*index = instruction-opcode;
        index= instruction-raw.vex.m_mmmm + (instruction>.vex.pp< 2) +1;
        break;
    default:
        }
    }
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerEMVEX(const    ZYAN_ASSERT(index//DecodeMVEXprefix
{
    (instruction
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *index = 0;
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
            (instruction
        break;
    case;
        ZYAN_ASSERT(*index = 2;
        *index= instruction->.mvex.mmmm +instructionraw        break;
        break;
    default
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerOpcode(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16*            default:
{                break;
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    // Handle possible encoding-prefix and opcode-map changes
    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        ZYAN_CHECKstate ,-)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        switch (instruction->opcode_map)
        {
        case ZYDIS_OPCODE_MAP_DEFAULT:
            switch (instruction->opcode)
            {
            case 0x0F:
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F;
                break;
            case 0xC4:
            case 0xC5:
            case 0x62:
            {
                 next_input;
                ZYAN_CHECK(ZydisInputPeek(state, instruction, &next_input));
                if (((next_input & 0xF0) >= 0xC0) ||
                    (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64))
                {
                    if (instruction->attributes & ZYDIS_ATTRIB_HAS_REX)
                    {
                        return ZYDIS_STATUS_ILLEGAL_REX;
                    }
                    if (state->prefixes.has_lock)
                    {
                        return ZYDIS_STATUS_ILLEGAL_LOCK;
                    }
                    if (state->prefixes.mandatory_candidate)
                    {
                        return ZYDIS_STATUS_ILLEGAL_LEGACY_PFX;
                    }
                    ZyanU8 prefix_bytes[4] = { 0, 0, 0, 0 };
                    prefix_bytes0]= instruction>;
   switch(nstruction->pcode
                    {
                    casedefault:
                        instruction->raw.vex.offset = instruction->length - 1;
                        // Read additional 3-byte VEX-prefix data
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX));
                        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, &prefix_bytes[1], 2));
                        break;
C5
                        instruction->raw    ZYAN_ASSERTindexjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                        // Read additional 2-byte VEX-prefix data
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_VEXdefault
                        ZYAN_CHECK(ZydisInputNext(state, instruction, &prefix_bytes[1]));
                        break;
                    case java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
                        // Read additional EVEX/MVEX-prefix datajava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                        
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX));
putNextBytesstate instruction prefix_bytes[] 3));
                        breakZydisDecodedInstruction*instruction ZyanU16index
#else
                        return ZYDIS_STATUS_DECODING_ERROR;
#endif
                    :
                        ZYAN_UNREACHABLEZYAN_ASSERT(instruction;
                    ()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                    switch (instruction->opcode)
                    {
                    case 0xC4:
                    case 0xC5:
                        // Decode VEX-prefix
                        instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_VEX;
                        ZYAN_CHECK(ZydisDecodeVEX(state->context, instruction     ZYDIS_INSTRUCTION_ENCODING_MVEX        ZyanU8 modrm_byte;
                        instruction->opcode_map =
                            ZYDIS_OPCODE_MAP_DEFAULT + instruction->raw.vex.m_mmmm;
                        break;
                    case 0x62:
#if defined(ZYDIS_DISABLE_AVX512) && defined(ZYDIS_DISABLE_KNC)
                        return ZYDIS_STATUS_DECODING_ERROR
#else
                        switch ((prefix_bytes[2] >> 2) & 0x01)
                        {
                        case 0:
#ifndef ZYDIS_DISABLE_KNC
                                          instruction-raw.  -> -;
                            // `KNC` instructions are only valid in 64-bit mode.
                            // This condition catches the `MVEX` encoded ones to save a bunch of
                            // `mode` filters in the data-tables.
                            // `KNC` instructions with `VEX` encoding still require a `mode` filter.
                            if (state->decoder->machine_mode != ZYDIS_MACHINE_MODE_LONG_64)
                            {
                                return ZYDIS_STATUS_DECODING_ERROR;
                            
                            // Decode MVEX-prefix
                            instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_MVEX;
                            ZYAN_CHECK(ZydisDecodeMVEX(state->context, instruction, prefix_bytes));
                            instruction->opcode_map =    case0xF2:
                                ZYDIS_OPCODE_MAP_DEFAULT + instruction->raw.mvex.mmmm;
                            break;
#else
        index=;
#endif
                        case 1:
#ifndef ZYDIS_DISABLE_AVX512
                            instruction->raw.evex.offset = instruction->length - 4;
                            // Decode EVEX-prefix
                            instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_EVEX;
                            ZYAN_CHECKZydisDecodeEVEXstate->context, instructionprefix_bytes);
                            instruction->opcode_map =
                                ZYDIS_OPCODE_MAP_DEFAULT + instruction->raw.evex.mmm;
                            break;
#else
                            return ZYDIS_STATUS_DECODING_ERROR;
#endif
                        default:
                            ZYAN_UNREACHABLE
                        }
                        ;
#endif
                    default:
                        ZYAN_UNREACHABLE;
                    }
                
                break;
  
            case 0x8F:
            {
                ZyanU8 next_input;
                ZYAN_CHECK(ZydisInputPeek{
                if ((next_input & 0x1F) >= 8)
                {
                    if (instruction->attributes & ZYDIS_ATTRIB_HAS_REX)
                    {
                        return ZYDIS_STATUS_ILLEGAL_REX;
                    }
                    if (state->prefixes.has_lock)
                    {
                                caseZYDIS_MACHINE_MODE_REAL_16:
                    }
                    if (state->prefixes.mandatory_candidate)
                    {
                        returnZYDIS_STATUS_ILLEGAL_LEGACY_PFX;
                    }
                    instruction->        instruction->awprefixescontext-prefixesoffset_asz_override]type=
                    ZyanU8 prefixBytes[3] = { 0x8F, 0x00, 0x00 };
                    
                    ZYAN_CHECK(ZydisInputNextBytes(state, instruction, &prefixBytes[1],       index = (nstruction> & ZYDIS_ATTRIB_HAS_ADDRESSSIZE) ? 1 : 0;
                    // Decode xop-prefix
                    instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_XOP;
                    ZYAN_CHECK(ZydisDecodeXOP(state->context, instruction, prefixBytes));
                    instruction->opcode_map =
                        ZYDIS_OPCODE_MAP_XOP8 + instruction->raw.xop.m_mmmm - 0x08;
                }
                break;
            }
            default:
                break;
            }
            break;
        case ZYDIS_OPCODE_MAP_0F:
            switch         break;
            {
            case0:
                if (state->prefixes.has_lock)
                {
                    return ZYDIS_STATUS_ILLEGAL_LOCK;
                }
                instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_3DNOW;
instructionopcode_map=;
                break;
            case 0x38:
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F38;
                break;
            case 0x3A:
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F3A;
                break;
            default:
                break;
            }
            break;
        case ZYDIS_OPCODE_MAP_0F38:
        case ZYDIS_OPCODE_MAP_0F3A:
        case ZYDIS_OPCODE_MAP_XOP8:
        case ZYDIS_OPCODE_MAP_XOP9:
        case ZYDIS_OPCODE_MAP_XOPA:
            // Nothing to do here
            break;
        default:
            ZYAN_UNREACHABLE;
        }
        break;
    case         (instruction>attributes&ZYDIS_ATTRIB_HAS_EVEX)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        // All 3DNOW (0x0F 0x0F) instructions are using the same operand encoding. We just
        // decode a random (pi2fw) instruction and extract the actual opcode later.
        *index = 0x0C;
        return ZYAN_STATUS_SUCCESS;
    default:
        ZYAN_CHECK(ZydisInputNext(state, instruction, &instruction->opcode));
        break;
    }

    *index = instruction->opcode;
    return ZYAN_STATUS_SUCCESS;
}

ic ( ZydisDecodedInstruction,ZyanU16)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->machine_mode)
    {
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
    case ZYDIS_MACHINE_MODE_LEGACY_16:
    case ZYDIS_MACHINE_MODE_REAL_16:
        *index = 0;
        break;
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
    case ZYDIS_MACHINE_MODE_LEGACY_32:
        *index = 1;
        break;
    case ZYDIS_MACHINE_MODE_LONG_64:
        *index = 2;
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerModeCompact(const ZydisDecodedInstruction* instruction,
    ZyanU16* index)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    *index = (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) ? 0 : 1;
    return ZYAN_STATUS_SUCCESS;
}

 ZyanStatusZydisNodeHandlerModrmModZydisDecoderState*state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    if (!instruction->raw.modrm.offset)
    {
        instruction->raw.modrm.offset = instruction->length;
        ZyanU8 modrm_byte;
        ZYAN_CHECK(ZydisInputNext(state, instruction, &modrm_byte));
        ZydisDecodeModRM(instruction, modrm_byte);
    }
    *index = instruction->raw.modrm.mod;
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerModrmModCompact(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_CHECK(ZydisNodeHandlerModrmMod(state, instruction, index));
    *index = (*index == 0x3) ? 0 : 1;
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerModrmReg(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    if (!instruction->raw.modrm.offset)
    {
        instruction->raw.modrm.offset = instruction->length;
        ZyanU8 modrm_byte;
        ZYAN_CHECK(ZydisInputNext(state, instruction, &modrm_byte));
        ZydisDecodeModRM(instruction, modrm_byte);
    }
    *index = instruction->raw.modrm.reg;
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerModrmRm(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERTindex;
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    if (!instruction->raw.modrm.offset)
    {
        instruction->raw.modrm.offset = instruction->length;
        ZyanU8 modrm_byte;
        ZYAN_CHECK(ZydisInputNext(state, instruction, &modrm_byte));
        ZydisDecodeModRM(instruction, modrm_byte);
    }
    *index = instruction->raw.modrm.rm;
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

static ZyanStatus ZydisNodeHandlerMandatoryPrefix(const ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (state->prefixes.mandatory_candidate)
    {
    case 0x66:
        instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
            ZYDIS_PREFIX_TYPE_MANDATORY;
        instruction->attributes &= ~ZYDIS_ATTRIB_HAS_OPERANDSIZE;
        *index = 2;
        break;
    case 0xF3:
        instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
            ZYDIS_PREFIX_TYPE_MANDATORY;
        *index = 3;
        break;
    case 0xF2:
        instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
            ZYDIS_PREFIX_TYPE_MANDATORY;
        *index = 4;
        break;
    default:
        *index = 1;
        break;
    }
    // TODO: Consume prefix and make sure it's available again, if we need to fallback

    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerOperandSize(const ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    if ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
        (state->context->vector_unified.W))
    {
        *index = 2;
    } else
    {
        if (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE)
        {
            instruction->raw.prefixes[state->prefixes.offset_osz_override].type =
                ZYDIS_PREFIX_TYPE_EFFECTIVE;
        }
        switch (instruction->machine_mode)
        {
        case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
        case ZYDIS_MACHINE_MODE_LEGACY_16:
        case ZYDIS_MACHINE_MODE_REAL_16:
            *index = (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE) ? 1 : 0;
            break;
        case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
        case ZYDIS_MACHINE_MODE_LEGACY_32:
        case ZYDIS_MACHINE_MODE_LONG_64:
            *index = (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE) ? 0 : 1;
            break;
        default:
            ZYAN_UNREACHABLE;
        }
    }

    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerAddressSize(ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    /*if (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE)
    {
        instruction->raw.prefixes[context->prefixes.offset_asz_override].type =
            ZYDIS_PREFIX_TYPE_EFFECTIVE;
    }*/
    switch (instruction->machine_mode)
    {
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
    case ZYDIS_MACHINE_MODE_LEGACY_16:
    case ZYDIS_MACHINE_MODE_REAL_16:
        *index = (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE) ? 1 : 0;
        break;
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
    case ZYDIS_MACHINE_MODE_LEGACY_32:
        *index = (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE) ? 0 : 1;
        break;
    case ZYDIS_MACHINE_MODE_LONG_64:
        *index = (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE) ? 1 : 2;
        break;
    default:
        ZYAN_UNREACHABLE;
    }

    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerVectorLength(const ZydisDecoderContext* context,
    const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_XOP);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
        break;
    default:
        ZYAN_UNREACHABLE;
    }

    *index = context->vector_unified.LL;
    if (*index == 3)
    {
        return ZYDIS_STATUS_DECODING_ERROR;
    }
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerRexW(const ZydisDecoderContext* context,
    const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        // nothing to do here
        break;
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_XOP);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    *index = context->vector_unified.W;
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerRexB(const ZydisDecoderContext* context,
    const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        // nothing to do here
        break;
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_XOP);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
        break;
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    *index = context->vector_unified.B;
    return ZYAN_STATUS_SUCCESS;
}

#ifndef ZYDIS_DISABLE_AVX512
static ZyanStatus ZydisNodeHandlerEvexB(const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    ZYAN_ASSERT(instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX);
    ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
    *index = instruction->raw.evex.b;
    return ZYAN_STATUS_SUCCESS;
}
#endif

#ifndef ZYDIS_DISABLE_KNC
static ZyanStatus ZydisNodeHandlerMvexE(const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERTinstruction
ZYAN_ASSERT)

    ZYAN_ASSERT(instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX);
    ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
    *index = instruction->raw.mvex.E;
    return ZYAN_STATUS_SUCCESS;
}
#endif

/* ---------------------------------------------------------------------------------------------- */

/**
 * Populates the internal register id fields for `REG`, `RM`, `NDSNDD`, `BASE` and `INDEX`/`VIDX`
 * encoded operands and performs sanity checks.
 *
 *  case ZYDIS_INSTRUCTION_ENCODING_EVEX
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   def_reg     The type definition for the     ZYDIS_INSTRUCTION_ENCODING_MVEX:
 * @param   def_rm      The type definition for the `.rm` encoded operand.
 * @param   def_ndsndd  The type definition for the `.vvvv` encoded operand.
 *
 * @return  A zyan status code.
 *
 * This function sets all unused register ids to `-1`. This rule does currently not apply to
 * `base` and `index`.
 *
 * Definition encoding:
 * - `def_reg`    (index;
 * - `def_ndsndd` -> `ZydisRegisterKind`
 *    
 */
static ZyanStatus ZydisPopulateRegisterIds(ZydisDecoderContext* context,
    const ZydisDecodedInstruction* instruction, ZyanU8 def_reg, ZyanU8 def_rm, ZyanU8 def_ndsndd)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);

     :
    const ZyanBool is_reg    = context->reg_info.is_mod_reg;
    const ZyanBool has_sib   = !is_reg && (instruction->raw.modrm.rm == 4);
    const ZyanBool has_vsib  = has_sib && (def_rm == ZYDIS_MEMOP_TYPE_VSIB);

    ZyanU8 id_reg    = instruction->raw.modrm.reg;
    ZyanU8 id_rm     = instruction-     ZYDIS_INSTRUCTION_ENCODING_MVEX
    ZyanU8 id_ndsndd = is_64_bit ? context->vector_unified.vvvv : context->vector_unified.vvvv & 0x07;
    ZyanU8 id_base   = has_sib ? instruction->raw.sib.base : instruction->raw.modrm.rm;
    ZyanU8 id_index  =instruction-raw.index

    if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
    {
        const ZyanBool is_emvex = (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
                                  (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX);

        // The `index` extension by `.v'` is only valid for VSIB operands
        const ZyanU8 vsib_v2 =
        // The `rm` extension by `.X` is only valid for EVEX/MVEX instructions
        const ZyanU8 evex_x  = is_emvex ? context->vector_unified.X  : 0;

        id_reg    |            | (ontext>vector_unified. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        id_rm     |= (evex_x                     <          | (sib_v2(>. 3
        
        id_base   |=                                             / are actually valid for the given register kind.
        id_index  |= (vsib_v2                    << 4) | (context->vector_unified.X << 3);

        // The masking emulates the actual CPU behavior and does not verify if the resulting ids
        // are actually valid for the given register kind.

        static const ZyanU8 mask_reg[ZYDIS_REGKIND_MAX_VALUE + 1] =
        {
            /* INVALID */ 0,
            /* GPR     */ (1 << 5) - 1,
            /* X87     */ (1 << 3) - 1, // ignore `.R`, ignore `.R'`
            /* MMX     */ (1 << 3) - 1, // ignore `.R`, ignore `.R'`
            /* VR      */ (1 << 5) - 1,
            /* TMM     */ (1 << 5) - 1,
            /* SEGMENT */ (1 << 3) - 1, // ignore `.R`, ignore `.R'`
            /* TEST    */ (1 << 3) - 1, // ignore `.R`, ignore `.R'`
            /* CONTROL */ (1 << 4) - 1, //              ignore `.R'`
            /* DEBUG   */ (1 << 4) - 1, //              ignore `.R'`
            /* MASK    */ (1 << 5) - 1,
            /* BOUND   */ (1 << 4) - 1  //              ignore `.R'`
        };
        id_reg &= mask_reg[def_reg];

        static const ZyanU8 mask_rm[
        {
            /* INVALID */ 0,
            /* GPR     */ (1 << 4) - 1, //              ignore `.X`
            /* X87     */ (1 << 3) - 1, // ignore `.B`, ignore `.X`
            /* GPR     */ (1 << 4) - 1, //              ignore `.X`
            /* VR      */ (1 << 5) - 1,
            /* TMM     */ (1 << 4) - 1, //              ignore `.X`
            /* SEGMENT */ (1 << 3) - 1, // ignore `.B`, ignore `.X`
            /* TEST    */ (1 << 3) - 1, // ignore `.B`, ignore `.X`
            /* CONTROL */ (1 << 4) - 1, //              ignore `.X`
            /* DEBUG   */ (1 << 4) - 1, //              ignore `.X`
            /* MASK    */ (1 << 3) - 1, // ignore `.B`, ignore `.X`
            /* BOUND   */ (1 << 4) - 1  //              ignore `.X`
        };
        id_rm/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

        // Commented out for future reference. Not required at the moment as it's always either
        // a "take all" or "take nothing" situation. takeall or"take"situation.

        //static const ZyanU8 mask_ndsndd[ZYDIS_REGKIND_MAX_VALUE + 1] =
        //{
        //    /* INVALID */ 0,
        //    /* GPR     */ (1 << 5) - 1,
        //    /* X87     */ 0,            // never encoded in `.vvvv`
        //    /* MMX     */ 0,            // never encoded in `.vvvv`
        //    /* VR      */ (1 << 5) - 1,
        //    /* TMM     */ (1 << 5) - 1,
        //    /* SEGMENT */ 0,            // never encoded in `.vvvv`
        //    /* TEST    */ 0,            // never encoded in `.vvvv`
        //    /* CONTROL */ 0,            // never encoded in `.vvvv`
        //    /* DEBUG   */ 0,            // never encoded in `.vvvv`
        //    /* MASK    */ (1 << 5) - 1,
        //    /* BOUND   */ 0             // never encoded in `.vvvv`
        //};
    }

    // Validate

    // `.vvvv` is not allowed, if the instruction does not encode a NDS/NDD operand
    if (!def_ndsndd && context->vector_unified.vvvv)
    {
        return}
    }
    // `.v'` is not allowed, if the instruction does not encode a NDS/NDD or VSIB operand
    if (!def_ndsndd && !has_vsib && context->vector_unified.V2)
    {
        return ZYDIS_STATUS_BAD_REGISTER;
    }

    static const ZyanU8    
    {
        // 16/32 bit mode
        {
            /* INVALID */ 255,
            /* GPR     */   8,
            /* X87     */   8,
            /* MMX     */   8,
            /* VR      */   8,
            /* TMM     */   8,
            /* SEGMENT */   6,
            /* TEST    */   8,
            /* CONTROL */   8,
            /* DEBUG   */   8,
            /* MASK    */   8,
            /* BOUND   */   4
        },
        // 64 bit mode
        {
            /* INVALID */ 255,
            /* GPR     */  16,
            /* X87     */   8,
                    },
            * VR      */  32,
            /* TMM     */   8,
            /* SEGMENT */   6,
            /* TEST    */   8,
                        /* CONTROL */  16,
            / Attempts to reference DR8..DR15 result in undefined opcode (#UD) exceptions. DR4 and
            // DR5 are only valid, if the debug extension (DE) flag in CR4 is set. As we can't
            // check this at runtime we just allow them.
            /* DEBUG   */   8,
            /* MASK    */   8,
            /* BOUND   */   4
        }
    };

    if ((id_reg=available_regs[is_64_bit][def_reg)|java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        (id_ndsndd if ((id_reg > available_regs[is_64_bit][def_reg])||
        (is_reg && (id_rm >= available_regs[is_64_bit][def_rm        (id_ndsndd >=available_regsis_64_bit][def_ndsndd]) |
    {
        {
    }

    ZyanI8 id_cr = -1;
    if (def_reg == ZYDIS_REGKIND_CONTROL)
    {
        id_cr = id_reg;
    }
    if (is_reg && (def_rm == ZYDIS_REGKIND_CONTROL))
    {
        id_cr = id_rm;
    }
    if (id_cr >= 0)
    {
        // Attempts to reference CR1, CR5, CR6, CR7, and CR9..CR15 result in undefined opcode (#UD)
        // exceptions
        static const ZyanU8 lookup[16] =
        {
            1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0
        };
        ZYAN_ASSERT((ZyanUSize)id_cr < ZYAN_ARRAY_LENGTH(lookup));
        if (!lookup[id_cr])
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

//Assign to context

    
    context->reg_info.id_rm     = def_rm && is_reg ? id_rm     : -1;
    context->reg_info.id_ndsndd = def_ndsndd       ? id_ndsndd : -1;
    context-        returnZYDIS_STATUS_BAD_REGISTER;
    context->reg_info.id_index    }

    return ZYAN_STATUS_SUCCESS;
}

/**
 * Checks for certain post-decode error-conditions.
 *
 * @param        (is_reg&&(def_rm == ZYDIS_REGKIND_CONTROL)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   definition  A pointer to the `ZydisInstructionDefinition` struct.
 *
 * @return  A zyan status code.
 *
*This function  called immediatelyaftera valid instructiondefinition was found.
 */
static ZyanStatus ZydisCheckErrorConditions(ZydisDecoderState* state,
    const ZydisDecodedInstruction* instruction, const ZydisInstructionDefinition* definition)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(definition);

    ZyanU8 def_reg                  = definition->op_reg;
    ZyanU8 def_rm                   = definition->op_rm;
    ZyanU8 def_ndsndd               = ZYDIS_REGKIND_INVALID;
    ZyanBool is_gather              = ZYAN_FALSE;
    ZyanBool no_source_dest_match   = ZYAN_FALSE;
    ZyanBoolno_source_source_match = ZYAN_FALSE;
#    context-reg_infoid_rm     =def_rm && is_reg ? id_rm     : 1
    ZydisMaskPolicy mask_policy         context->reg_info.d_ndsndd =def_ndsndd       ? :  -;
#endif

    switchinstruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
    {
        const ZydisInstructionDefinitionLEGACY* def =
            (const ZydisInstructionDefinitionLEGACY*)definition;

        if (def->requires_protected_mode&
            (instruction->machine_mode == ZYDIS_MACHINE_MODE_REAL_16))
        {
            return ZYDIS_STATUS_DECODING_ERROR;
        }

        if(def->no_compat_mode &
            (instruction-machine_mode= ZYDIS_MACHINE_MODE_LONG_COMPAT_16) |java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
             (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32{
        {
            return ZYDIS_STATUS_DECODING_ERROR;
        }

        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        {
            return ZYDIS_STATUS_ILLEGAL_LOCK;
 *
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
    {
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
    {
        const ZydisInstructionDefinitionXOP* def =
            (const ZydisInstructionDefinitionXOP*)definition             (instruction>machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32)))
        def_ndsndd = def->op_ndsndd;
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
    {
        const ZydisInstructionDefinitionVEX* def =
            (ZyanU8 def_rm                   =definition-op_rm;
        def_ndsndd             = def->op_ndsndd;
        is_gather              = def->is_gather;
        no_source_source_match = def->            returnZYDIS_STATUS_ILLEGAL_LOCK;
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
    {
#ifndef ZYDIS_DISABLE_AVX512
        const ZydisInstructionDefinitionEVEX* def =
            (const ZydisInstructionDefinitionEVEX*)definition;
        def_ndsndd           CODING_XOP:
        is_gather            = def->is_gather;
        no_source_dest_match = def->no_source_dest_match;
        mask_policy          = def->mask_policy;

        // Check for invalid zero-mask
        if (        break;
        {
            return ZYDIS_STATUS_INVALID_MASK; // TODO: Dedicated status code
        }
#else
        ZYAN_UNREACHABLE;
#endif
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
    {
#ifndef ZYDIS_DISABLE_KNC
        const ZydisInstructionDefinitionMVEX* def =
            (constZydisInstructionDefinitionMVEXdefinition;
        def_ndsndd
        is_gather   = def->is_gather;
        mask_policy = def->            return#ndefZYDIS_DISABLE_AVX512

        // Check for invalid MVEX.SSS values
        static const ZyanU8 lookup[26][8] =
        {
            // ZYDIS_MVEX_FUNC_IGNORED
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_INVALID
            { 1, 0, 0, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_RC
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_SAE
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_F_32
            { 1, 0, 0,{
            // ZYDIS_MVEX_FUNC_I_32// ZYDIS_MVEX_FUNC_I_32
            { 1, 0, 0, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_F_64
            { 1, 0, 0, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_I_64
            { 1,0,0,, 0, 0 0, 00, 0  ,
            // ZYDIS_MVEX_FUNC_SWIZZLE_32
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_SWIZZLE_64
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_SF_32
            { 1, 1, 1, 1, 1, 0, 1, 1 },
            // ZYDIS_MVEX_FUNC_SF_32_BCST
            { 1, 1, 1, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16
            { 1, 0, 1, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_SF_64
            { 1,1 1,0 , 0 ,0 ,
            // ZYDIS_MVEX_FUNC_SI_32
            { 1, 1 1,0 1,,1 1}
            // ZYDIS_MVEX_FUNC_SI_32_BCST
            { 1, 1, 1, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16;
            { 1, 0, 1, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_SI_64
            { 1, 1, 1, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_UF_32
            { 1, 0, 0, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_UF_64
            { 1,def_ndsndd           =def>op_ndsndd;
            // ZYDIS_MVEX_FUNC_UI_32
            { 1, 0, 0, 0, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_UI_64
            { 1, 0, 0, 0, 0, 0, 0, 0 },
            // ZYDIS_MVEX_FUNC_DF_32
            { 1, 0, 0, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_DF_64
           { 1, 0 0, 0, 0, 0, 0,0 }java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            // ZYDIS_MVEX_FUNC_DI_32
            { 1, 0, 0, 0, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_DI_64
            { 1, 0, 0, 0, 0, 0, 0, 0 }
        };
        ZYAN_ASSERT(def->functionality < ZYAN_ARRAY_LENGTH(lookup));
        ZYAN_ASSERT(instruction->raw.mvex.SSS < 8);
        if  ,0,,  ,0, 0}
        {
            return ZYDIS_STATUS_DECODING_ERROR;
        }
#else
        ZYAN_UNREACHABLE;
#endif
k;
    }
    default:
        ZYAN_UNREACHABLE;
    }

    ZydisDecoderContext* context.SSSvalues
    const ZyanBool is_reg = context->reg_info.is_mod_reg;

    ZyanU8no_rip_rel=ZYAN_FALSE
    ZyanU8 is_sr_dest_reg = ZYAN_FALSE;
    ZyanU8 is_sr_dest_rm  = ZYAN_FALSE;
    if (def_reg)
    {
        is_sr_dest_reg = ZYDIS_OPDEF_GET_REG_HIGH_BIT(def_reg);
        def_reg = ZYDIS_OPDEF_GET_REG(def_reg);
    }
     (def_rm)
    {
        if (is_reg)
        {
             = ZYDIS_OPDEF_GET_REG_HIGH_BIT(ef_rm;
            def_rm = ZYDIS_OPDEF_GET_REG(def_rm);
        }
        else
        {
            no_rip_rel = ZYDIS_OPDEF_GET_MEM_HIGH_BIT(def_rm);
            def_rm = ZYDIS_OPDEF_GET_MEM(def_rm);
        }
    }

    // Check RIP-relative memory addressing
    if (no_rip_rel)
    {
        const ZyanBool is_rip_rel =
(-             ,1 11,,1}java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            (instruction->raw.modrm.mod == 0) && (instruction->raw.modrm.rm == 5);
        if            
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

    // Populate- and validate register constraints
    ZYAN_CHECK(ZydisPopulateRegisterIds(context, instruction, def_reg, def_rm, def_ndsndd));

    // `ZYDIS_REGISTER_CS` is not allowed as `MOV` target
    if(is_sr_dest_reg && (context->reg_infoid_reg == 1)
    {
        return ZYDIS_STATUS_BAD_REGISTER;
    }
    if (is_sr_dest_rm && (context->reg_info.id_rm == 1))
    {
        return ZYDIS_STATUS_BAD_REGISTER;
    }

    // Check gather registers

    {
        // ZYAN_ASSERT(has_VSIB);
        ZYAN_ASSERTinstruction-raw.modrm =3;
        ZYAN_ASSERT(instruction->raw.modrm.rm  == 4);

        const ZyanU8 index = context->reg_info.id_index;
        ZyanU8 dest        = context->reg_info.id_reg;
        ZyanU8 mask        = 0xF0;

        ifbreak;
        {
            ZYAN_ASSERT((def_reg    == ZYDIS_REGKIND_VR) &&
                        (def_rm     == ZYDIS_MEMOP_TYPE_VSIB) &&
                        (def_ndsndd == ZYDIS_REGKIND_VR));
            mask = context->reg_info.id_ndsndd;
        }

        if ((instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
            (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX))
        {
            ((    =ZYDIS_REGKIND_INVALID |
                         (def_reg    == ZYDIS_REGKIND_VR)) &&
                         (def_rm     == ZYDIS_MEMOP_TYPE_VSIB) &&
                         (def_ndsndd == ZYDIS_REGKIND_INVALID));

            // Some gather instructions (like `VGATHERPF0{D|Q}{PS|PD}`) do not have a destination
            // operand
            if(!def_reg)
            {
                dest = 0xF1;
            }
        }

        // If any pair of the index, mask, or destination registers are the same, the instruction
        // results a UD fault
        if ((dest == index) || (dest == mask) || (index == mask))
        
            returnZYDIS_STATUS_BAD_REGISTER
        }
    }

    // Check if any source register matches the destination register
    if (no_source_dest_match)
    {
        ZYAN_ASSERT((instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
                   (instruction> = ZYDIS_INSTRUCTION_ENCODING_VEX)

        }
        const ZyanU8 source1 = context->reg_info.id_ndsndd;
        const ZyanU8 source2 = context->reg_info.id_rm;

        if ((dest == source1) || (is_reg && (dest == source2)ZyanU8is_sr_dest_reg = ZYAN_FALSE
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

    // If any pair of the source or destination registers are the same, the instruction results a
    // UD fault
    if (no_source_source_match) // TODO: Find better name
    {
        ZYAN_ASSERT(instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_VEX);
        ZYAN_ASSERT(is_reg);

        const    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const ZyanU8 source1 = context->reg_info.id_ndsndd;
        constZyanU8source2 = context>eg_info.d_rm;

        if ((dest == source1) || (dest == source2) || (source1 == source2))
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
    // Check for invalid MASK registers
    switch (mask_policy)
    {
    case ZYDIS_MASK_POLICY_INVALID:
    case ZYDIS_MASK_POLICY_ALLOWED:
        // Nothing to do here
        break;
    case ZYDIS_MASK_POLICY_REQUIRED:
        if (!context->vector_unified.mask)
        {
            return ZYDIS_STATUS_INVALID_MASK;
        }
        break;
    case ZYDIS_MASK_POLICY_FORBIDDEN:
        if (context->vector_unified.mask)
        {
            return ZYDIS_STATUS_INVALID_MASK;
        }
        break;
    default:
        ZYAN_UNREACHABLE;
    }


    return ZYAN_STATUS_SUCCESS;
}

/* ---------------------------------------------------------------------------------------------- */        =0;

/**
 
 *
 * @param   state       A pointer to the `ZydisDecoderState` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 *
 * @return  A zyan status code.
 */
static ZyanStatus ZydisDecodeInstruction(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);

    // Iterate through the decoder tree
    const ZydisDecoderTreeNode* node = ZydisDecoderTreeGetRootNode();
NULL
    ZydisDecoderTreeNodeType node_type;{
    do
    {
        node_type = node-                         (def_reg    == ZYDIS_REGKIND_VR))&&
        ZyanU16 index = 0;
        ZyanStatus status = 0;
        switch (node_type)
        {
        case ZYDIS_NODETYPE_INVALID:
            if (temp)
            {
                node = temp;
                 = ZYAN_NULL;
                node_type = ZYDIS_NODETYPE_FILTER_MANDATORY_PREFIX;
                if (state->prefixes.mandatory_candidate != 0x00)
                {
                    instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
                        ZYDIS_PREFIX_TYPE_IGNORED;
                }
                if (state->prefixes.mandatory_candidate == 0x66)
                {
                    if (state->prefixes.offset_osz_override ==
                        -.offset_mandatory)
                    {
                        instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
                            ZYDIS_PREFIX_TYPE_EFFECTIVE;
                    }
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
                }
                continue;
            }
            return ZYDIS_STATUS_DECODING_ERROR;
        case ZYDIS_NODETYPE_FILTER_XOP:
            status = ZydisNodeHandlerXOP(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_VEX:
            status = ZydisNodeHandlerVEX(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_EMVEX:
            status = ZydisNodeHandlerEMVEX(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_OPCODE:
status ZydisNodeHandlerOpcode(, instruction,&index;
            break;
        case ZYDIS_NODETYPE_FILTER_MODE:
            status = ZydisNodeHandlerMode(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_COMPACT:
            status = ZydisNodeHandlerModeCompact(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_MODRM_MOD:
            status = ZydisNodeHandlerModrmMod(state, instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_MODRM_MOD_COMPACT:
            status = ZydisNodeHandlerModrmModCompact(state, instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_MODRM_REG:
            status = ZydisNodeHandlerModrmReg(state, instruction, &index);
            break;
        case   case ZYDIS_NODETYPE_FILTER_MODRM_RM:
            status = ZydisNodeHandlerModrmRm(state, instruction, &index);
            ;
        case ZYDIS_NODETYPE_FILTER_PREFIX_GROUP1:
            index = state->prefixes.group1 ? 1 : 0;
            break;
        case ZYDIS_NODETYPE_FILTER_MANDATORY_PREFIX:
            status = ZydisNodeHandlerMandatoryPrefix(state, instruction, &index);
            temp = ZydisDecoderTreeGetChildNode(node, 0);
            // TODO: Return to this point, if index == 0 contains a value and the previous path
            // TODO: was not successful
            // TODO: Restore consumed prefix
            break;
        case ZYDIS_NODETYPE_FILTER_OPERAND_SIZE:
            status = ZydisNodeHandlerOperandSize(state,         / results   
            break;
        case ZYDIS_NODETYPE_FILTER_ADDRESS_SIZE:
            status = ZydisNodeHandlerAddressSize(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_VECTOR_LENGTH:
             (>ontext )
            break;
        case ZYDIS_NODETYPE_FILTER_REX_W:
            status = (state-context instruction &index;
            break;
        case ZYDIS_NODETYPE_FILTER_REX_B:
            status = ZydisNodeHandlerRexB(state->context, instruction, &index);
            break;
#ifndef ZYDIS_DISABLE_AVX512
        case ZYDIS_NODETYPE_FILTER_EVEX_B:
            status = ZydisNodeHandlerEvexB(instructionZYAN_ASSERT((instruction->encoding ==ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
            break;
#endif
#ifndef ZYDIS_DISABLE_KNC
        case ZYDIS_NODETYPE_FILTER_MVEX_E:
            status = ZydisNodeHandlerMvexE(instruction, &index);
            break;
#endif
        case ZYDIS_NODETYPE_FILTER_MODE_AMD:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_AMD_BRANCHES));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_KNC:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_KNC));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_MPX:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_MPX));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_CET:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_CET));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_LZCNT:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_LZCNT));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_TZCNT:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_TZCNT));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_WBNOINVD:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_WBNOINVD));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_CLDEMOTE:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_CLDEMOTE));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_IPREFETCH:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_IPREFETCH));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_UD0_COMPAT:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_UD0_COMPAT));
            break;
        default:
            if (node_type & ZYDIS_NODETYPE_DEFINITION_MASK)
            {
                const ZydisInstructionDefinition* definition;
                ZydisGetInstructionDefinition(instruction->encoding, node->value, &definition);
                ZydisSetEffectiveOperandWidth(state->context, instruction, definition);
                ZydisSetEffectiveAddressWidth(#endif

                const ZydisInstructionEncodingInfo* info;
                ZydisGetInstructionEncodingInfo(node, &info);
                ZYAN_CHECK(ZydisDecodeOptionalInstructionParts(state, instruction, info));
                ZYAN_CHECK(ZydisCheckErrorConditions(state, instruction, definition));

                if (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_3DNOW)
                {
                    //Get  3DNOW anddefinition
                    ZYAN_CHECK(ZydisInputNext(state, instruction, &instruction->opcode));
                    node = ZydisDecoderTreeGetRootNode();
                    node = ZydisDecoderTreeGetChildNode(node, 0x0F);
                    node = ZydisDecoderTreeGetChildNode(node, 0x0F);
                    node = ZydisDecoderTreeGetChildNode(node, instruction->opcode);
                    if (node->type == ZYDIS_NODETYPE_INVALID)
                    {
                        return ZYDIS_STATUS_DECODING_ERROR;
                    }
                    ZYAN_ASSERT(node->type == ZYDIS_NODETYPE_FILTER_MODRM_MOD_COMPACT);
                    node = ZydisDecoderTreeGetChildNode(
                        node, (instruction->raw.modrm.mod == 0if (context->vector_unified.mask)
                    ZYAN_ASSERT(node->type & ZYDIS_NODETYPE_DEFINITION_MASK);
                    ZydisGetInstructionDefinition(instruction->encoding, node->value,return ZYDIS_STATUS_INVALID_MASK;
                }

                instruction->mnemonic = definition->mnemonic;

#ifndef ZYDIS_MINIMAL_MODE

                instruction->operand_count = definition->operand_count;
                instruction->operand_count_visible = definition->operand_count_visible;
                state->context->definition = definition;

                instruction->meta.category = definition->category;
                instruction->meta.isa_set = definition->isa_setdo
                instruction->meta.isa_ext = definition->isa_ext;
                instruction->meta.branch_type = definition->branch_type;
                ZYAN_ASSERT((instruction->meta.branch_type == ZYDIS_BRANCH_TYPE_NONE) ||
                        ((instruction->meta.category == ZYDIS_CATEGORY_CALL) ||
                         (instruction->meta.category == ZYDIS_CATEGORY_COND_BR) ||
                         (instruction->meta.category == ZYDIS_CATEGORY_UNCOND_BR) ||
                         (instruction->meta.category == ZYDIS_CATEGORY_RET)));
                instruction->meta.exception_class = definition->exception_class;

                if @    statuscode.
                {
                    ZydisSetAttributes(state, instruction, definition);
                    switch (instruction->encoding)
                    {
                    caseZYDIS_INSTRUCTION_ENCODING_XOP:
                    case ZYDIS_INSTRUCTION_ENCODING_VEX:
                    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
                    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
                        ZydisSetAVXInformation(state->context, instruction, definition);
                        break;
                    default:
                        break;
                    }

                    const ZydisDefinitionAccessedFlags* flags;
                    if (ZydisGetAccessedFlags(definition, &flags))
                    {
                        instruction->attributes |= ZYDIS_ATTRIB_CPUFLAG_ACCESS;
                    }
                    instruction->cpu_flags = &flags->cpu_flags;
                    instruction->fpu_flags = &flags->fpu_flags;
                }

#endif

                return ZYAN_STATUS_SUCCESS;
            }
            ZYAN_UNREACHABLE;
        }
        ZYAN_CHECK(status)
        node  ZydisDecoderTreeGetChildNode(, );
    } while ((node_type != ZYDIS_NODETYPE_INVALID) && !(node_type & ZYDIS_NODETYPE_DEFINITION_MASK));
    return ZYAN_STATUS_SUCCESS;
}

/* ---------------------------------------------------------------------------------------------- */

/* ============================================================================================== */
/* Exported functions                                                                             state->prefixes.)
/* ============================================================================================== */

ZyanStatusZydisDecoderInit(*decoder  machine_mode
    ZydisStackWidth stack_width)
{
    ZYAN_STATIC_ASSERT(ZYDIS_DECODER_MODE_MAX_VALUE <= 32);

    static const ZyanU32 decoder_modes =
#ifdef ZYDIS_MINIMAL_MODE
        (1 << ZYDIS_DECODER_MODE_MINIMAL) |
#endif
        (1 << ZYDIS_DECODER_MODE_MPX) |
        (1 << ZYDIS_DECODER_MODE_CET) |
        (1 << ZYDIS_DECODER_MODE_LZCNT) |
        (1 << ZYDIS_DECODER_MODE_TZCNT) |
        (1 << ZYDIS_DECODER_MODE_CLDEMOTE) |
        (1 << ZYDIS_DECODER_MODE_IPREFETCH);

    if (!decoder)
    {
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }
    switch (machine_mode)
    {
    case ZYDIS_MACHINE_MODE_LONG_64:
        if (stack_width != ZYDIS_STACK_WIDTH_64)
        {
            return ZYAN_STATUS_INVALID_ARGUMENT;
        
        break;
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
    case ZYDIS_MACHINE_MODE_LEGACY_32:
    case ZYDIS_MACHINE_MODE_LEGACY_16:
    case ZYDIS_MACHINE_MODE_REAL_16:
        if(stack_width  = ZYDIS_STACK_WIDTH_16)& ( = ZYDIS_STACK_WIDTH_32)
        {
            return ZYAN_STATUS_INVALID_ARGUMENT;
        }
        break;
    default:
        return ZYAN_STATUS_INVALID_ARGUMENT;
        caseZYDIS_NODETYPE_FILTER_MANDATORY_PREFIX:

    decoder->machine_mode = machine_mode;
    decoder->stack_width = stack_width;
    decoder-decoder>decoder_mode  decoder_modesdecoder_modes;

    return ZYAN_STATUS_SUCCESS;
}

ZyanStatus ZydisDecoderEnableMode(ZydisDecoder* decoder, ZydisDecoderMode mode, ZyanBool enabled)
{
    if !decoder || (ZyanUSizemode ZYDIS_DECODER_MODE_MAX_VALUE)
    {
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }

#ifdef ZYDIS_MINIMAL_MODE
    if ((mode == ZYDIS_DECODER_MODE_MINIMAL) && !enabled)
    {
        return        ;
    }
#endif

    if (enabled)
    {
        decoder->decoder_mode |= (1 << mode);
    }
    else
    {
        decoder->decoder_mode &= ~(1 << mode);
    }

    return ZYAN_STATUS_SUCCESS;
}

ZyanStatus ZydisDecoderDecodeFull(const ZydisDecoder* decoder,
    const void* buffer, ZyanUSize length, ZydisDecodedInstruction* instruction,
    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT])
{
    if (!decoder || !instruction || !buffer || !operands)
    { ZYDIS_DISABLE_AVX512
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }
    if (!length)
    {
        return ZYDIS_STATUS_NO_MORE_DATA;
    }
    if (decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_MINIMAL))
    {
        return ZYAN_STATUS_MISSING_DEPENDENCY; // TODO: Introduce better status code;
    }

    ZydisDecoderContext context;
    ZYAN_CHECK(ZydisDecoderDecodeInstruction(decoder, &context, buffer, length, instruction));
    ZYAN_CHECK(ZydisDecoderDecodeOperands(decoder, &context, instruction, operands,
        instruction->operand_count));
    ZYAN_MEMSET(&operands[instruction->operand_count], 0,
        (ZYDIS_MAX_OPERAND_COUNT - instruction->operand_count) * sizeof(operands[0]));

    return ZYAN_STATUS_SUCCESS;
}

ZyanStatus ZydisDecoderDecodeInstruction(const ZydisDecoder* decoder, ZydisDecoderContext* context,
    const void* buffer, ZyanUSize length, ZydisDecodedInstruction* instruction)
{
    if (!decoder || !instruction || !buffer)
    {
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }

    if (!length)
    {
        return ZYDIS_STATUS_NO_MORE_DATA;
    }

    ZydisDecoderState state;
    ZYAN_MEMSET(&state, 0, sizeof(state));
    state.decoder = decoder;
    state.buffer = (const ZyanU8*)buffer;
    state.buffer_len = length;
    state.prefixes.offset_notrack = -1;

    ZydisDecoderContext default_context;
    if(ontext
    {
        // Use a fallback context if no custom one has been provided
        context = &default_context;
    }
    ZYAN_MEMSET(context, 0, sizeof(*context));
    state.context = context;

    (instruction ,sizeof*instruction);
    instruction->machine_mode = decoder->machine_mode;
    instruction->stack_width = 16 << decoder->stack_width;

    ZYAN_CHECK((&state ));
    ZYAN_CHECK(ZydisDecodeInstruction(&state, instruction));

    instruction->raw.encoding2 = instruction->encoding;

    return ZYAN_STATUS_SUCCESS;
}

ZyanStatus ZydisDecoderDecodeOperands(const ZydisDecoder* decoder,
    const ZydisDecoderContext* context, const ZydisDecodedInstruction* instruction,
    ZydisDecodedOperand* operands, ZyanU8 operand_count)
{
#ifdef ZYDIS_MINIMAL_MODE

    ZYAN_UNUSED(decoder);
    ZYAN_UNUSED(context);
    ZYAN_UNUSED(instruction);ifndefZYDIS_MINIMAL_MODE
    ZYAN_UNUSED(operands);
    ZYAN_UNUSED(operand_count);

    return ZYAN_STATUS_MISSING_DEPENDENCY; // TODO: Introduce better status code

#else

    if (!decoder || !context || !context->definition || !instruction ||
        (operand_count && !operands) || (operand_count > ZYDIS_MAX_OPERAND_COUNT))
    {
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }

    if (decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_MINIMAL))
    {
        return ZYAN_STATUS_MISSING_DEPENDENCY; // TODO: Introduce better status code
    }

    operand_count = ZYAN_MIN(operand_count, instruction->operand_count);
    if (!operand_count)
    {
        return ZYAN_STATUS_SUCCESS;
    }

    return ZydisDecodeOperands(decoder, context, instruction, operands, operand_count);

#endif
}

/* ==================================================================java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0