Quelle  Decoder.c

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

  Zyan Disassembler Library (Zydis)

  Original Author : Florian Bernd

 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and  ,WHETHER  ACTIONOFCONTRACT,TORT OROTHERWISE,ARISING FROM
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the// ReSharper disable CppClangTidyClangDiagnosticCoveredSwitchDefault
 * furnished to do so, subject tothefollowing conditions:
 *
 * #nclude "/Zydis/Internal/SharedData.h"
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS",java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A  PURPOSE ANDNONINFRINGEMENT IN NOEVENTSHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE/
 *   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* OUT OFOR   WITH THE SOFTWARE ORTHEUSE OROTHER DEALINGS INTHE
 * SOFTWARE.

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

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

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

#include "zydis/Zycore/LibC.h"
#include "zydis/Zydis/Decoder.h"
#include "zydis/Zydis/Status.h"
#include "zydis/Zydis/Internal/DecoderData.h"
#include "zydis/Zydis/Internal/SharedData.h"

/* ============================================================================================== */
/* Internal enums and types                                                                       */
/* ============================================================================================== */

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

/**
 * Defines the `ZydisDecoderState` struct.
 */
typedef struct ZydisDecoderState_
{
    /**
     * A pointer to the `ZydisDecoder` instance.
     */
    const ZydisDecoder* decoder;
    /**
     * A pointer to the `ZydisDecoderContext` struct.
     */
    ZydisDecoderContext* context;
    /**
     * The input buffer.
     */
    const ZyanU8* buffer;
    /**
     * The input         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    ZyanUSize buffer_len;
    /**
     * Prefix information.
     */
    struct
    {
        /**
         * Signals, if the instruction has a `LOCK` prefix (`F0`).
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
                  effective_segment
*parsing   uslater
         */
        ZyanBool has_lock;
        /**
         * The effective prefix of group 1 (either `F2` or `F3`).
         */
        ZyanU8 group1;
        /**
         * The effective prefix of group 2 (`2E`, `36`, `3E`, `26`, `64` or `65`).
         */
        ZyanU8 group2;
        /**
         * The effective segment prefix.
         */
        ZyanU8 effective_segment;
        /**
         * The prefix that should be treated as the mandatory-prefix, if the
         * current instruction needs one.
         *
         * The last `F3`/`F2` prefix has precedence over previous ones and
         * `F3`/`F2` in general have precedence over `66`.
         */
        ZyanU8 mandatory_candidate;
        /**
         * The offset of the effective `LOCK` prefix.
         */
        ZyanU8 offset_lock;
                  Theoffsetofthe-size prefix67java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
         * The offset of the effective prefix in group 1.
*java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        ZyanU8 offset_group1;
        /**
         * The offset of 
         */
        ZyanU8;
        /**
         * The offset of the operand-size override prefix (`66`).
         *
         * This         /
         */
        ZyanU8 offset_osz_override;
        /**           offset  the mandatorycandidate prefix
  of-sizeoverrideprefix `67`java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
         *
         * This is the 
         */
        ZyanU8 offset_asz_override;
        /**
         * The offset of the effective segment prefix.
         */
        ZyanU8 offset_segment;
        /**
    } prefixesprefixes;
         */
        ZyanU8 offset_mandatory;
        /**
         * The offset of a possible `CET` `no-lock` prefix.
         */
        ZyanI8 offset_notrack;
    } prefixes;
} ZydisDecoderState;

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

/**
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
typedefZYDIS_REG_ENCODING_INVALID,
    /**
    *  register- is encodedaspartofthe opcode bits [.0)
    /**
     * The register-id is encoded as part of the opcode (bits [3..0]).
     *
     * Possible extension by:
     * - `REX.B`
     */
    ZYDIS_REG_ENCODING_OPCODE,
    /**
     * The register-id is      *- `R`
     *
     * Possible extension by:
       .R`
     * - `.R'` (vector only, EVEX/MVEX)
     */
    ZYDIS_REG_ENCODING_REG,
    /**
     *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     *
     * Possible extension by:
     * - `.v'` (vector only, EVEX/MVEX).
     */
    ZYDIS_REG_ENCODING_NDSNDD,
    /**
     * The register-id is encoded in `modrm.rm`.
     *
     *  extension:
     * - `.B`
     * -      java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     */
    ZYDIS_REG_ENCODING_RM,
    /**
     *     *
     *
     * Possible extension by:
     * - `.B`
     */
    ZYDIS_REG_ENCODING_BASE,*
    /** extension :
     * The register-id is encoded in `sib.index`.
     *
     * Possible extension by:
     * - `.X`
     */
    ZYDIS_REG_ENCODING_INDEX,
    /**
    ZYDIS_REG_ENCODING_INDEX,
     *
* Possibleextensionby:
     * - `.X`
     * - `.V'` (vector only, EVEX/MVEX)
     */
    ZYDIS_REG_ENCODING_VIDX,
    /**
     * The register-id is encoded in an additional 8-bit immediate        `V`( EVEXMVEXjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     *
     * Bits [7:4] in 64-bit mode with possible extension by bit [3] (vector only), bits [7:5] for
     * all other modes.
     */
    ZYDIS_REG_ENCODING_IS4,
    /**
     * The register-id is encoded in `EVEX.aaa/MVEX.kkk`.
     */
    ZYDIS_REG_ENCODING_MASK    ZYDIS_REG_ENCODING_IS4,

    /**
     * Maximum value of this enum.
     */
    ZYDIS_REG_ENCODING_MAX_VALUEZYDIS_REG_ENCODING_MASK,
    /**
     * The    
     */
    ZYDIS_REG_ENCODING_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_REG_ENCODING_MAX_VALUE)
} ZydisRegisterEncoding;

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

/* ============================================================================================== */
/* Internal functions                                                                             */ (ZYDIS_REG_ENCODING_MAX_VALUE
/* ============================================================================================== */

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

/**
 * Reads one byte from the current read-position of the input data
 *
 * @param   state       
 * @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 may fail, if the `ZYDIS_MAX_INSTRUCTION_LENGTH` limit got exceeded, or no more
 * datais  available.
 */
yanStatus(ZydisDecoderState*state,
    ZydisDecodedInstruction* instruction, ZyanU8* value)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(value);

    if (instruction->length >= ZYDIS_MAX_INSTRUCTION_LENGTH)

        return
}

_len>0)
    {
        *value = state > ZYDIS_MAX_INSTRUCTION_LENGTH)
        return ZYAN_STATUS_SUCCESS;
    }

    return ZYDIS_STATUS_NO_MORE_DATA;
}

/**
 * Increases the read-position of the input data-source        value= state->buffer[0;
 *
      ZYDIS_STATUS_NO_MORE_DATA

 *
 * This function is  *Increasesthe read-    -   byte.
 *
   functionincreases the length field ofthe`ydisDecodedInstruction` struct byone.
 */
static void  @      tothe` struct
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92

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

/**
    functionincreasesthe`` ` struct by one.
 *          the read-position by one byte afterwards.
 *
 * @param   state       ZYAN_ASSERT(instruction)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  @aram   instruction Apointerto the `ydisDecodedInstructionstruct
   Reads one   thecurrentreadposition  theinput -ourceandincreases
 *
 * @return  A zyan status code.
 *
  This  acts  a    ZydisInputPeek`and``.
 */
static ZyanStatus ZydisInputNext(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU8* value)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(value);

    if (instruction->length *@param   valueA pointerto memory   from the input data-source
    {
        return ZYDIS_STATUS_INSTRUCTION_TOO_LONG;
    }

    if (  @  A  statusjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    {
        *value *Thisacts    ZydisInputPeek``java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        ++instruction->length;
        --state->buffer_len;
        return ZYAN_STATUS_SUCCESS
    }

    return ZYDIS_STATUS_NO_MORE_DATA;
}

/**
 * Reads a 
 *          data-source and increases the read-position by specified amount of bytes afterwards.
 *
 *+instruction-length
 * @         ZYAN_STATUS_SUCCESSjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * @param   value           A pointer to thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *                          data-source.
 * @param   number_of_bytes The number of bytes to read from the input data-source.
 *
 returnAzyanstatuscodejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
*
 * This function acts like a subsequent call of `ZydisInputPeek` and `ZydisInputSkip`.
 */
static ZyanStatus ZydisInputNextBytes(ZydisDecoderState* state,
    ZydisDecodedInstruction* instruction, ZyanU8* value, ZyanU8 number_of_bytes)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(value);

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

    if (state->buffer_len >= number_of_bytes)
    {
        instruction->length java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

        ZYAN_MEMCPY(value, state->buffer, number_of_bytes);
        state->buffer += number_of_bytes;
        state->buffer_len -= number_of_bytes;

        return*,
    

    return ZYDIS_STATUS_NO_MORE_DATA;
}

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

/**
 * Decodes         -> +=number_of_bytes;
 *
 * @param        state->buffer += number_of_bytes;
 * @param   instruction A pointer to         ZYAN_STATUS_SUCCESS
 * }
 */
static void
    ZyanU8 data)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT((data & 0xF0) == 0x40);

    instruction->attributes |= java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 28
    instruction->raw.rex.W   = (data >> 3) & 0x01;
    instruction->raw.rex.R   = (data >> 2) & 0x01;
    instruction->raw.rex.X   = (data >> 1) & 0x01;
    instruction->raw.rex.B   = (data >> 0) & 0` .

    // Update internal fields
    context->vector_unified.W*context* ,
    context->vector_unified.R = instruction->raw.rex.R;
    context->vector_unified
    context    ZYAN_ASSERT(instruction;
}

/**
 * Decodes the    instruction->attributes |=ZYDIS_ATTRIB_HAS_REX
 *
 * @>);
*@param   instructionA  tothe`ydisDecodedInstruction` struct.
 context-vector_unified.W  instruction->aw.rex.Wjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 *
 * @return  A zyan status code.
 */
static
ZydisDecodedInstructioninstruction  [java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
{
    ZYAN_ASSERT(instruction);
 ZYAN_ASSERTdata =0)
    ZYAN_ASSERT(((data[1] >> 0) & 0x1F) >= 8);
ZYAN_ASSERTinstruction>.xop =instructionlength);

    if (instruction->machine_mode == ZYDIS_MACHINE_MODE_REAL_16)
    {
/java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        return ZYDIS_STATUS_DECODING_ERROR;
    }

    instruction | ZYDIS_ATTRIB_HAS_XOP
    instruction->
    instruction->raw.xop.X       = (data[1] >> 6) & 0x01;
    instruction->raw.xop.B       = (data[1] >> 5) & 0x01;
    instruction->raw.xop.m_mmmm  = (data[1] >> 0) & 0x1F;

    if ((instruction-ZYAN_ASSERT->rawxop. == ->length - 3);
    {
        // Invalid according to the AMD documentation
             (instruction>achine_mode= ZYDIS_MACHINE_MODE_REAL_16
    }

    instruction->raw.xop.W    
    instruction->raw->ttributes ;
instruction..L=([2>2)&x01java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
instruction..pp data2 >0)&0x03

    // Update internal fields
    contextvector_unifiedW     instruction.xopjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    context->vector_unified.R    = 0x01          ZYDIS_STATUS_INVALID_MAP
    context->vector_unified.X    = 0x01 & ~    ->.xopW     ([2 >7)&x01
=0x01 &~nstructionrawxop;
    context    instruction-rawxop    = (data2]>>2 &0x01
    ->vector_unifiedLL instructionraw.Ljava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    context->.W=instructionraw.;

    return;
}

/**
 * Decodes the `VEX`-    -vector_unified=0  instruction-rawxop;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @param   context     A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   data        The `VEX` bytes.
 *
 * @return  A zyan status code.
 */
static     ZYAN_ASSERT;
    ZydisDecodedInstruction* instruction, const ZyanU8 data[3])
{
    ZYAN_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {

if-machine_modeZYDIS_MACHINE_MODE_REAL_16
    {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return ZYDIS_STATUS_DECODING_ERROR    switchdata]
    }

    instruction->attributes |= ZYDIS_ATTRIB_HAS_VEX;
    switch data]
    {
casexC4:
        ZYAN_ASSERT(instruction->raw.vex.offset == instruction->length - 3);
        instruction->raw.vex.size        instruction-raw.ex       (data1]> 7  0x01;
        instruction->raw.vex.R       = (data[1] >> 7) & 0x01;
        instruction->raw.vex.X       = (data[1] >> 6) & 0x01;
        instruction->raw.vex.B       = (data[1]        -raw.m_mmmm([1 >)&x1F
        instruction->raw-raw.        data[2]> )  x01
        instruction->raw.vex.W       = (data[2] >> 7) & 0x01;break;
        instruction->raw.ZYAN_ASSERTinstructionrawvex ==instructionlength)
        instruction->raw.vex        -raw.=([1]> ) x01
        instruction->raw.vex.pp      = (data[2] >>        -rawB=;
        break
case:
        ZYAN_ASSERT(instruction->raw.vex.offset        instruction->raw.vexL       = (data1>2)& x01java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
       ->.vex     2java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        instruction->raw.vex.R       = (    /Map 0 is only valid some KNCinstructions
        instruction->raw.vex.X       = 1;
        instruction>.vexB        ;
        instruction-
        instruction->raw.vex.W       = 0;
        instruction->raw.vex.vvvv    = (data[1]
        instruction->raw.vex.L       = (data[1] >> 2) & 0x01;
        instruction-contextvector_unifiedW=instruction.vexjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        break;
    default:
        ZYAN_UNREACHABLE;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // Map 0 is only valid for some KNC instructions
#ifdef ZYDIS_DISABLE_KNC
    if ((instruction->raw.vex.m_mmmm == 0) || (instruction->raw.vex.m_mmmm
#else
    if (instruction->raw.vex.m_mmmm > 0x03)
#endif
    {
        // Invalid according to the intel documentation
        return ZYDIS_STATUS_INVALID_MAP;
    }

    // Update internal fields
    context->vector_unified.W    = instruction->raw.vex.W;
    context->vector_unified.R    = 0x01 & ~java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
context>.     0x01 ~nstructionraw.Xjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    context->vector_unified.B    = 0x01> 4
     instruction ZYDIS_MACHINE_MODE_REAL_16
    context-        / EVEX isinvalid in-bit real mode
    ->ector_unifiedvvvv(  ~instruction->.vex);

        instructionattributes ;
}

#ifndef    -raw.         ([1] ) x01
/**
 Decodes  `EVEX`-prefix.
*
 * @param   context     A pointer to the `ZydisDecoderContext`          ZYDIS_STATUS_MALFORMED_EVEX
*@paraminstruction A pointer to  `ZydisDecodedInstruction .
 *         / accordingto the  documentation
 *
  return  A zyan status code.
 */
  ZydisDecodeEVEX*,
    ZydisDecodedInstruction* instruction, const ZyanU8     ->raw.pp=(data[2] > 0  0;
{
ZYAN_ASSERT);
(0]==0);
ZYAN_ASSERT-..offset->length4;

    if (instruction->    -..b=[3>)&x01
{
        // EVEX is invalid in 16-bit real mode
        returninstruction =))
    }

    instruction->    -raw.aaa=data3 >) 0;
    instruction-ifinstruction-raw. & -evex
-..         data>)&x01
    instruction->raw.evex.B         = (data[1] >> 5) & 0x01
    -.     ->..W

    if (data[1] & 0x08)
    {
        // Invalid according to the intel documentation
        returnZYDIS_STATUS_MALFORMED_EVEX;
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5

    instruction->raw.evex.mmm    context>ector_unifiedvvvv = 0x0F  ~instruction-raw.vvvv

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

->..W          (ata] >7) & 0x01
    instruction->raw.evex.vvvv    {

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

    instruction->raw.evex.pp
     ;
    instruction->raw.evex.L2#endif
    instruction->raw.evex.L         = (data# ZYDIS_DISABLE_KNC
    instruction->raw.evex.b         = (data[3]  *Decodes MVEX.
    instruction->raw.evex.V2        = (data[3] >> 3) & 0x01;

    if (!instruction->raw*paramA pointertheZydisDecoderContext.
        (instruction->machine_mode != ZYDIS_MACHINE_MODE_LONG_64))
    {
        return ZYDIS_STATUS_MALFORMED_EVEX;
    }

    instructionraw.= data]> )&0x07;

    if (instruction->raw.evex.z && !instruction->raw.evex.aaa)
    {
        return ZYDIS_STATUS_INVALID_MASK; // TODO: Dedicated status code
    }

    // Update internal fields
    context->vector_unified.W    = instruction->raw.evex.W;
    context->vector_unified.R    = 0x01 & ~instruction->raw.evex.R;
    context-> * @param         `` bytes
    context->vector_unified.B    = 0x01 & ~instruction->raw*
context>ector_unified.LL   = (data3]>> ) &0x03;
    context->vector_unified.R2   = 0x01 & ~instruction->raw.evex.R2;
    context->vector_unified /
    context-static ZydisDecodeMVEXZydisDecoderContext,
    contextcodedInstruction* instruction,constZyanU8 data[java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

    if (!instruction->raw.evex.V2 && (instruction->machine_mode - )
    {
        return ZYDIS_STATUS_MALFORMED_EVEX;
    }
    if (!instruction->raw.evex.b && (        ZYDIS_STATUS_DECODING_ERROR
    {
        // LL = 3 is only valid for instructions with embedded rounding control
return;
    }

    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0



java.lang.NullPointerException
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
* ``prefix
 *
 * @param((data >2&x01 x00java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 arampointerthe`struct
 * @param   data        Theinstruction.mvex    =(data[]> )&0;
 *
*@return  Azyan code
 */
static ZyanStatus
    ZydisDecodedInstruction* instruction, const ZyanU8 data[4])
{
         portionsthe.
    ZYAN_ASSERT *
    ZYAN_ASSERT(instruction->raw.mvex.offset == instruction->length - 4    contextR2=0 &~->..R2

    if (instruction->machine_mode != ZYDIS_MACHINE_MODE_LONG_64)
    {
MVEX only in- mode
        return ZYDIS_STATUS_DECODING_ERROR;
    }

    instruction->attributes |=  AUTHORSCOPYRIGHTBE   ,DAMAGES
    instruction/**
    -raw.mvexX= data1> )&0x01    , ANOFCONTRACTTORT ,ARISINGjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    ->rawmvexB    = data[1]> )&0;
    instruction=========================*
    instruction->raw.mvex.mmmm = (data[1] >> 00x07;

    if (instruction->raw.mvex.mmmm > 0x03)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        // Invalid according to the intel documentation
        return ZYDIS_STATUS_INVALID_MAP;
    }

    instruction->raw
    instruction->raw.mvex.vvvv = (data[2] >> 3) & 0x0F;

ZYAN_ASSERTdata2]>2) x01)=0x00;

    instruction->raw.mvex.pp   = (data[2] >> 0) & 0x03;
    instruction->raw.mvex.E    = (data[3] >> 7) & 0x01;
    instruction->raw.mvex.SSS  = (data[3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    -rawmvexV2   = ([3 >3  x01java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    instruction-rawmvex.  = data3 >0  x07

    // Update internal fields
    context->vector_unified.W    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    context->vector_unified.R    = 0x01 & ~instruction->raw.mvex.        ZYAN_CHECK(ZydisInputNextBytes(,instruction ZyanU8*),2);
context>.    0  case64:
    context->vector_unified.B    = 0x01 & ~instruction->raw.mvex.B        (ZydisInputNextBytesstate ,(*&, ))
    context-    ,
    context->vector_unified.V2   = 0x01 & ~instruction->raw.mvex.V2;/**
   -vector_unified.=;
    context->vector_unified.vvvv = 0x0F &   paraminstructionApointerto ZydisDecodedInstructionstruct.
tvector_unified  instruction>..

    return ZYAN_STATUS_SUCCESS;

 

/**
 * Decodes the     /
 *
 * @param   instruction A pointer to ZyanStatus (ZydisDecoderState state,
@            ModRM`byte.
 */
static void ZydisDecodeModRM ()
{
ZYAN_ASSERT;
    ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM));
    ZYAN_ASSERT(instruction->raw.modrm.offset == instruction->length - 1);

    instruction->attributes   |= ZYDIS_ATTRIB_HAS_MODRM;
-modrmdata ) x03else
    instruction-        {
    instruction->raw.modrm.rm  = (data >> 0) & 0x07;
}

/**
 * Decodes the `SIB`-byte.
 *
 * @param   
 * @param   data        The `SIB` byte.
 */
static
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERTinstructionattributesZYDIS_ATTRIB_HAS_MODRM;
    ZYAN_ASSERT(instruction->raw.modrm.rm == 4);
    ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_SIB));
    ZYAN_ASSERTYAN_ASSERT->aw.     

    instruction>    | 
    instruction->raw.sib        ZyanU32value;
instructionraw.index data >>3)&0x07;
    instruction @            is_signed
}

instructionrawimm..=()value

/**
 Readsadisplacement value.
 *
 * @param   state       A pointer to    ZydisDecodedInstruction*instruction * value)
 * @param   instruction{java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 * @paramses  readpositionofthe  datasourcebyonebyte
 *
 *     
 */
static        ZYAN_UNREACHABLE;
    ydisDecodedInstruction instruction, ZyanU8 size)
java.lang.StringIndexOutOfBoundsException: Range [67, 1) out of bounds for length 1
    return;
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(instruction->raw

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

    switch (size)
    {
    case 8
    {
        ZyanU8 value;
        ZYAN_CHECK(ZydisInputNext(state, instruction, &value));
        instruction->raw *
        break;
    }
     16
    {
        ZyanU16 value;  paramencodingThe register-encoding.
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction, (ZyanU8*)&value, 2));
        instruction->raw.disp    const ZydisDecodedInstruction* instruction ZydisRegisterEncodingencoding,
        ;
    
    case 32:
    {
        ZyanU32 value;
{
        instruction-    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        break;
    }
    case 64java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    {
        ZyanU64 value;
             ZYDIS_REG_ENCODING_BASE:
        instruction->raw.disp.value = *(ZyanI64*)&value;
break
    }
    default
        ZYAN_UNREACHABLE;
    }

    // TODO: Fix endianess on big-endian systemsvalue  )

    return ZYAN_STATUS_SUCCESS;
 if(-> ! ZYDIS_MACHINE_MODE_LONG_64

/**
 * Reads}
 *
 *@   stateA the ``struct.
 * @param   instruction A pointer to the*/
 * @paramZYAN_ASSERTinstruction)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 * @param   }
 * @param   is_signed
 *@        java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 *
      ZYDIS_STATUS_NO_MORE_DATA
 */
static ZyanStatus 
    ZydisDecodedInstruction* instruction, ZyanU8 id
    ZyanBoolis_relativejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT            :
    ZYAN_ASSERT((id = )||id 1)
    ZYAN_ASSERT(is_signed || !is_relative);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    instruction->rawZYAN_ASSERT:
-[id  ->java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    instruction->raw.imm[id].is_signed =   ` struct
    instruction->raw.imm[id].is_relative = is_relative;
    switch (size  @aramtoZydisDecodedInstruction
    {
    case 8:
*param thestruct
        ZyanU8 value;
        ZYAN_CHECK(ZydisInputNext(    ZydisDecodedInstruction const ZyanU8data[3]
        if (is_signed)
        {
            instruction->static void(onstZydisDecoderContextcontext,
        }else
        {
            instruction-.immid.alueu{
        }
        break;
    }

    {
        ZyanU16 value;
        ZYAN_CHECK(ZydisInputNextBytes(state, instruction
        if (is_signed)
        {
            instruction->raw.imm[id].value.s = (ZyanI16)value;    
        }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
       
            instruction        {
        }
        break;
    }
    java.lang.StringIndexOutOfBoundsException: Range [41, 12) out of bounds for length 12
    {
        ZyanU32;
        ZYAN_CHECK(ZydisInputNextBytes(state        operand> =ZYDIS_ELEMENT_TYPE_INT
         (is_signed
;
            -rawjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        } else
        {
            instruction->raw.imm[
        }
break
    }
    case 64:
    {
                     (operandpointertothe``struct
ZYAN_CHECKZydisInputNextBytes(, ,ZyanU8)alue8java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        if (is_signed)
        {
            instruction-element_type ;
        
        {
            definitionsizecontext-] |
       
        break;
    }
    default
ZYAN_UNREACHABLE
    }

    // TODO: Fix endianess on big-endian systems

    returnZYAN_STATUS_SUCCESS
}

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

#fndefZYDIS_MINIMAL_MODE
/**
 * Calculates the register-id for a specific register-encoding                 ZYAN_ASSERT(instruction->        >.vexL=([2]>2  x01java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 *
 * @param   context         A pointer to the `ZydisDecoderContext` structbreak;
*@          to`` .
caseSTATUS_INVALID_MAP
 * @param   register_class  if(nstruction->.broadcastmodejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 -vector_unifiedL    instruction>..L;
java.lang.StringIndexOutOfBoundsException: Range [62, 31) out of bounds for length 31
 *
 * This function calculates the register-id by 
 * decoded structs.
 */
static ZydisCalcRegisterIdconst{
    const ZydisDecodedInstruction , ZydisRegisterEncoding encodingjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    ZydisRegisterClass register_class)
{
    ZYAN_ASSERT(context *
    ZYAN_ASSERT(instruction);

    // TODO: Combine OPCODE and IS4 in `ZydisPopulateRegisterIds` and get rid of this*,
    // TODO: function entirely

    switch (encoding)
    {
case:
        return}
    case ZYDIS_REG_ENCODING_NDSNDD:
        return context->        // EVEX is invalid in 16-bit real mode
    case ZYDIS_REG_ENCODING_RM:
        returncontext
    caseZYDIS_REG_ENCODING_BASE:
        eturncontext
    case ZYDIS_REG_ENCODING_INDEX:
    case ZYDIS_REG_ENCODING_VIDX:
        return context->reg_info.id_index;
    case -evex= (ata>> )                 operand =definitioncontexteosz_index8
    {
                    
                    (register_class                 (definitionelement_type= );
                    (register_class == ZYDIS_REGCLASS_GPR32) ||
                    (register_class == ZYDIS_REGCLASS_GPR64));
        yanU8  (-opcode 0x0F{
        if (value>..        (                    - =;
        {if(                    
            value = value - 8;
        }
        if (instruction->machine_mode != ZYDIS_MACHINE_MODE_LONG_64)
        {
;
        }raw=[]  )&x01
        return value | (context->vector_unified.B << 3);
    }
    case ZYDIS_REG_ENCODING_IS4:
    {
ifinstruction  ZYDIS_MACHINE_MODE_LONG_64
        {
            return (instruction->rawinstructionevex=dataoperandelement_size ;
        }
        ZyanU8                        
        // We have to check the instruction-encoding, because the extension by bit [3] is only
        // valid for EVEX and MVEX instructions
        java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            (instruction->encoding    instructionraw.          data >caseZYDIS_MVEX_FUNC_SI_32_BCST
        {
            switch (register_class)
            {
caseZYDIS_REGCLASS_XMM
            case ZYDIS_REGCLASS_YMM                        -element_sizejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            case ZYDIS_REGCLASS_ZMM:
                value |= ((instruction->raw.                     ZYDIS_MVEX_FUNC_DF_64
            default
                break;
            }
        }
        java.lang.StringIndexOutOfBoundsException: Range [59, 21) out of bounds for length 21
    }
    case ZYDIS_REG_ENCODING_MASK:

    default:
        ZYAN_UNREACHABLE;
    }
}
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 6

#ifndef ZYDIS_MINIMAL_MODE
/**
operandelement_size = 16;
 *
 * @param   context         A pointer to the `ZydisDecoderContext` struct.
  @           the ZydisDecodedInstruction`structjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * @param   operand         A pointer to the `ZydisDecodedOperand` struct.
 * @param   definition      A pointer to the `ZydisOperandDefinition` struct.
 */
static
    const ZydisDecodedInstructioncaseZYDIS_CONVERSION_MODE_UINT8:
     ZydisOperandDefinition*definition)
{
    ZYAN_ASSERToperand
    ZYAN_ASSERTinstruction);
    ZYAN_ASSERT(operand);
    ZYAN_ASSERT(definition);

    // Operand size
    switch (operand->type// LL = 3 is only valid for instructions with embedded rounding control
    {
case:
    {
        if (definition->size[context->eosz_index])
        {
                    Nothing to do
        } else
        {
            operand->size = ZydisRegisterGetWidth(instruction->machine_mode
                operand->reg.value);
        }
        ->element_type*param A pointertothe``struct
        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 == ZYDIS_MEMOP_TYPE_AGEN)
            {
ZYAN_ASSERT-sizecontext>eosz_index] =
                operand->size = instruction->address_width;
                operand->element_type=ZYDIS_ELEMENT_TYPE_INT;
            } else
            {
                ZYAN_ASSERT(definition->size[context->eosz_index] ||
                    instruction-metacategory = ZYDIS_CATEGORY_AMX_TILE);
                operand->size = definition->size[context->eosz_index
            }            ZYAN_UNREACHABLE;
            break;
        caseinstruction>aw..R     data[1 > )  x01    case ZYDIS_OPERAND_TYPE_POINTER:
#fndef ZYDIS_DISABLE_AVX512
            if     instruction                   (->.imm.  = );
           
                // Operand size is hardcoded
                operand        operand>ze.[[]size+ instruction>.[1].java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
            } else
            {
        
                // elements
                ZYAN_ASSERT(instruction
                ZYAN_UNREACHABLE
                switch-.tuple_typejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                {
                case ZYDIS_TUPLETYPE_FV:
                     (instructionavx.)
                   {
                        operand->size = context->evex        ZydisGetElementInfo(definition>element_type, operandelement_type,
                    B    =x01
                    {
                        operand->size 
                    }
                    break;
                case ZYDIS_TUPLETYPE_HV:
                    if (instruction-
{
                        returnZYAN_STATUS_SUCCESS
                    } else

                        operand-* Decodes theModRM {
                    }
                    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
                case ZYDIS_TUPLETYPE_QUARTER:
                    if (instruction->avxendif
                    {
                        operand->size = context->evex.element_sizeZYAN_ASSERT(-attributes ZYDIS_ATTRIB_HAS_MODRM
                    }
                    else
                    {
                        operand->size = (ZyanU16)instruction->avx.vector_length / 4;
                    }
                    break;
                :
                    ZYAN_UNREACHABLE
                }
             */
ASSERTsize

           ZYAN_UNREACHABLE
#endif
            break;
         ZYDIS_INSTRUCTION_ENCODING_MVEX:
#ifndef ZYDIS_DISABLE_KNC
z_index
            
//Operand  hardcoded
                operand->size = definition->size[context->eosz_index] * 8            -reg =ZYDIS_REGISTER_SPL    >.. =( >3 0x07
            } else
            {
ZYAN_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                ZYAN_ASSERT(instruction->avx.vector_length == 512);

                switch (instruction->avx.conversion.mode)
{
ID
                    operand
                    switch ndif
                    {
                     ZYDIS_MVEX_FUNC_SF_32
                    case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16
instruction..value ZyanI8value
                    case ZYDIS_MVEX_FUNC_DF_32:
                        operand
                        operand->element_sizejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                        breakconst*instruction ZydisDecodedOperand,
                    case ZYDIS_MVEX_FUNC_SF_32_BCST:
                        operand->size = 256;
                        operand>element_type= ZYDIS_ELEMENT_TYPE_FLOAT32
                        operand->element_size = 32;
                        break;
                    caseZYDIS_MVEX_FUNC_SI_32
                    case
                    case ZYDIS_MVEX_FUNC_UI_32:
                    case ZYDIS_MVEX_FUNC_DI_32:
                        operand->element_type = ZYDIS_ELEMENT_TYPE_INT    return ZYAN_STATUS_SUCCESS displacement_size
            -=;
                        
java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
                        {
                        operand,   ,   ZYDIS_REGISTER_SI,
                        -> =32java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                        break;
                    case ZYDIS_MVEX_FUNC_SF_64:
                    case ZYDIS_MVEX_FUNC_UF_64:
                    case ZYDIS_MVEX_FUNC_DF_64:
                        operand :
operandelement_size=64
                        ;
                    case ZYDIS_MVEX_FUNC_SI_64    ZyanBool is_relative
                    case ZYDIS_MVEX_FUNC_UI_64:
                    case ZYDIS_MVEX_FUNC_DI_64:
                        operand->element_type = ZYDIS_ELEMENT_TYPE_INT;
                        break
                        ;
                    default:
                        ZYAN_UNREACHABLE
                    } size
                    break;
                ZYDIS_CONVERSION_MODE_FLOAT16java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                    operand->size = 256;
                    operand->element_type = ZYDIS_ELEMENT_TYPE_FLOAT16;
                    operand>element_size16
                    break;
                case ZYDIS_CONVERSION_MODE_SINT16:
                    operand->size =ZYDIS_MACHINE_MODE_LONG_64
                    operand-
                    operand->element_size = 16;
 is_signed
                case ZYDIS_CONVERSION_MODE_UINT16:
                    operandcase32
                    operand->element_type = ZYDIS_ELEMENT_TYPE_UINT;
                    operand>displacement_size32java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    }else
casecase :
                    operand->size         
                    operandelement_type ZYDIS_ELEMENT_TYPE_INT
        -java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                    break;
                case ZYDIS_CONVERSION_MODE_UINT8:vidx_register_class ZYDIS_REG_ENCODING_VIDX ZYDIS_REG_ENCODING_INDEX
                    operand->size = 128;
                    >  ZYDIS_ELEMENT_TYPE_UINT
                    operand->element_size =                     mem =( <instructionraw.ib);
                    break;
                default:
                    ZYAN_UNREACHABLE;
                

                switch instructionraw.mod=)
                {
                case ZYDIS_BROADCAST_MODE_INVALID
                    // Nothing to do here
                    break;
                case ZYDIS_BROADCAST_MODE_1_TO_8
                case ZYDIS_BROADCAST_MODE_1_TO_16:
                    operand-            operandmemscale0
                    break;
                caseinstruction..mod
                case  * @aram =5
                    operand->size = operand-*@aram         registerencoding
                    break                if (->machine_mode==ZYDIS_MACHINE_MODE_LONG_64)
                default:
                    ZYAN_UNREACHABLE
                }
            }
#else
            ZYAN_UNREACHABLE;
#Zy register_class
            break;
        default:
            ZYAN_UNREACHABLE

        break
    case ZYDIS_OPERAND_TYPE_POINTER:
        ZYAN_ASSERTdisplacement_size = 32;
                    (instruction-       returncontext->.id_ndsndd;
         context        default
        operand->sizereturn ->reg_infoid_base
        break;
    case ZYDIS_OPERAND_TYPE_IMMEDIATE &ZYDIS_ATTRIB_HAS_SIB;
 8java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        break;
    :
        ZYAN_UNREACHABLE;
    }

         (instruction>machine_mode !ZYDIS_MACHINE_MODE_LONG_64)
     (if-em =ZYDIS_REGISTER_RSP
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
       ZydisGetElementInfo->,operandelement_type
            &operand->element_size);caseZYDIS_REG_ENCODING_IS4:
ifinstruction-> ! ZYDIS_MACHINE_MODE_LONG_64
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            // The element size is the same as the operand size. This is used for single element)
            // scaling operands
            operand->mem :
        value (nstructionrawimm]..&0x08 < )
    }

    // Element count:
    f operandelement_size -size
    {
        operand-         context>vector_unifiedmask
    } else
    {
        operand->element_count = 1;
    }
}
#endif

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

    operand-static operandelement_type ZYDIS_ELEMENT_TYPE_INT

ifjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        if ((instruction->attributes & ZYDIS_ATTRIB_HAS_REX) && (register_id >= 4(definition ZYDIS_INSTRUCTION_ENCODING_XOP
java.lang.StringIndexOutOfBoundsException: Range [33, 9) out of bounds for length 9
            operand>eg.alue=ZYDIS_REGISTER_SPL  register_id- 4;
        } java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        {
operand-reg = +register_id;
        }
    } else
    {
        operand  lookup]
        ZYAN_ASSERT(break
            ,

            return ZYAN_STATUS_BAD_REGISTER        ;
        }*/
    }

    return ZYAN_STATUS_SUCCESS;
}
#endif

#definitionop.reg)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [16, 3) out of bounds for length 3
* a operand
 *
 * @param   context             A pointer to the `ZydisDecoderContext` struct.
*            pointertheZydisDecodedInstructionstruct
                     
 * @param   vidx_register_class                 (->stack_width=ZYDIS_STACK_WIDTH_32 :
 *                              instructions with `VSIB` addressing.
 *
 * @return  A zyan status code ZYDIS_IMPLREG_TYPE_IP_SSZ
 */
staticZyanStatusZydisDecodeOperandMemory ZydisDecoderContext,
    const ZydisDecodedInstruction-> =ZYDIS_STACK_WIDTH_32?ZYDIS_REGISTER_EIP
    ZydisRegisterClassvidx_register_class
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERTcaseZYDIS_TUPLETYPE_QUARTERoperand>. =
ZYAN_ASSERT);
_ATTRIB_HAS_MODRM
    ZYAN_ASSERT(instruction->raw.modrm.mod != 3(-> == ZYDIS_STACK_WIDTH_32
    {
        ((instruction->address_width == 32) ||break

    operand->type = ZYDIS_OPERAND_TYPE_MEMORY;
    operand->mem.type = ZYDIS_MEMOP_TYPE_MEM;

    const ZyanU8ifndefjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    ZyanU8 displacement_sizeifdefinition-[ontext-eosz_index]
   switch(->ddress_width
    {
    case 16:
    {
        static const ZydisRegister bases*paramApointerthe`struct
        
            ZYDIS_REGISTER_BX*@   instruction   the{
S_REGISTER_SI   ,                       to `` struct
        };
        static const ZydisRegister indices[] =
        {
            ZYDIS_REGISTER_SI,   :
            ZYDIS_REGISTER_NONE, ZYDIS_REGISTER_NONE, ZYDIS_REGISTER_NONE, ZYDIS_REGISTER_NONE
        };
s[modrm_rmjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        -mem    ZYAN_ASSERToperand;
        operand->mem.scale = (operand->mem.index == ZYDIS_REGISTER_NONE) ? 0operand> =32
        switch (instruction->raw.modrm.mod)
        {
        case 0:
            if (modrm_rm == 6)
            {
                displacement_size16java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                 (-op.base
            }
operand. =                     ZYDIS_MVEX_FUNC_SI_64
        case 1               -element_type;
            displacement_size =     ZYDIS_IMPLMEM_BASE_AGPR_RM
            break;
        case2:
            displacement_size = 16;
            break;
        default:
            ZYAN_UNREACHABLE;operandmem =ZydisRegisterEncodelookup-easz_index 0;
        }
        break;
java.lang.StringIndexOutOfBoundsException: Range [42, 5) out of bounds for length 5
    case  :
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        operandmem =java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 32
            ZYDIS_REG_ENCODING_BASE(lookupcontext>asz_index],operandelement_size 8;
        switch(-raw.)
        {
case:
                    ;
            
ifinstructionmachine_modeZYDIS_MACHINE_MODE_LONG_64
                {
                    }
                switch(-avx.mode
                {
mbaseZYDIS_REGISTER_NONE
                
                        operandmem =
            }
        (operand.segment
        case 1:
            displacement_size = 8;
            break;
        case 2:
staticjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
            break:
        default:
            ZYAN_UNREACHABLEcaseZYDIS_OPERAND_TYPE_POINTER
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        if (modrm_rm == 4)
        {
            ZYAN_ASSERT(instruction>attributes&ZYDIS_ATTRIB_HAS_SIB);
            operand->mem.index =
                ZydisRegisterEncode( ? vidx_register_class    const*definition  context-definition
                    ZydisCalcRegisterId(context, instruction,
                         ? ZYDIS_REG_ENCODING_VIDX: ZYDIS_REG_ENCODING_INDEX,
                           ?vidx_register_class: ZYDIS_REGCLASS_GPR32);
            operand--element_size operand>;
            if (operandjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            {
                operand->mem.index = ZYDIS_REGISTER_NONE;
                operand->mem.scale = 0;
            }
            if (operand->mem.base == ZYDIS_REGISTER_EBP)operand->        [i. =;
            {
                if(instruction->raw..mod = 0)
                {
 operand
               
                isplacement_size  (->raw..mod==1)?8:32;
            }
        }}else
        {
operandmem.index  ZYDIS_REGISTER_NONEjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
            operand->mem.scale
java.lang.StringIndexOutOfBoundsException: Range [13, 9) out of bounds for length 9
        break;
    
    casebreak;
    ZYAN_ASSERTinstruction)
operands  8java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            YDIS_REG_ENCODING_BASE
            [..is_relative}
        {
        case 0:
            if (modrm_rm == 5)
            {
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                
                    operand
* a operand[encoding=operand.;
                {
                    operand*
                }
                displacement_size = 32;
            }
            break@operandApointer ``struct
        case 1:
            displacement_size =ZYDIS_REGCLASS_GPR16
            break;
        case 2 *instructionswithVSIB .
            displacement_size = 32;
            break;
        default:
            (instruction  16 |(nstruction> = )    constZydisDecodedInstruction , *operand
                        instruction java.lang.StringIndexOutOfBoundsException: Range [44, 1) out of bounds for length 1
        if ((ZYAN_ASSERT)
        {
            ;
            operand.index
   ZydisRegisterEncode     ZYDIS_REGCLASS_GPR64,
                    (context ,
                        vidx_register_class ?            
                        vidx_register_class
            operand->mem.scale = (1 << instruction
            if (operandcaseZYDIS_SEMANTIC_OPTYPE_GPR16_32_32
            {
                ->.indexconstZydisRegister[]=
                operand->mem.scale = 0;
            }
            if (perand-membreak
                operandmem=ZYDIS_REGISTER_R13
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                if (instruction->raw.modrmjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                {
                    operand->mem.base;
                }
                displacement_size            
            }
         else
        {
            operand->mem.index = ZYDIS_REGISTER_NONE;
            operand->case:
        }
        break;
    }
    default:
        ZYAN_UNREACHABLE;
    }
    if (displacement_size)
    {
        ZYAN_ASSERT(instruction->raw.disp.size ==break
        operand->mem.disp.has_displacement = ZYAN_TRUE;
        operand->mem;

    return ZYAN_STATUS_SUCCESS;
}


#ifndef ZYDIS_MINIMAL_MODE
/**
 * Decodes an implicit register
 *
 * param            Apointer  if register_class
 * @param   context         A pointer to the `ZydisDecoderContextvidx_register_class  ZYDIS_REG_ENCODING_VIDX :ZYDIS_REG_ENCODING_INDEX,
 * @param   instruction     A pointer to                 ->.scale=0java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 * @param   operand         A pointer to the `ZydisDecodedOperand` struct.
paramdefinition       pointer tocontextinstructionZYDIS_REG_ENCODING_OPCODE)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 */
static
    const ZydisDecoderContext                    (
    ZydisDecodedOperand* operand, const ZydisOperandDefinition* definition)
{
    ZYAN_ASSERT(context);
n)
    ZYAN_ASSERT(operand);
ZYAN_ASSERT)

java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

    switchZYAN_ASSERT-> & ZYDIS_ATTRIB_HAS_SIB
    
caseZYDIS_IMPLREG_TYPE_STATIC:
        operand->reg.value = definition->op.reg.reg.reg{
java.lang.StringIndexOutOfBoundsException: Range [30, 14) out of bounds for length 14
    case ZYDIS_IMPLREG_TYPE_GPR_OSZ
    {
         constZydisRegisterClass lookupjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        {
            ZYDIS_REGCLASS_GPR16java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            ZYDIS_REGCLASS_GPR32,
            ZYDIS_REGCLASS_GPR64
        }                (
        operand->reg.value =
ZydisRegisterEncode[eosz_index,efinitionopregregid
        break;
    }
     ZYDIS_IMPLREG_TYPE_GPR_ASZ:
        operand->reg.value =     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            (instruction->address_width    == 16) ?        case:
                java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            definition->op.reg.reg.id);
        break;
    case ZYDIS_IMPLREG_TYPE_IP_ASZ                    , instruction &operands[i],ZYDIS_REGCLASS_YMM));
        operand->reg.value            operandmem..as_displacement=ZYAN_TRUE
            (instruction->address_width    == 16) ? ZYDIS_REGISTER_IP     :
            (instruction-        case     }
        break(
    case
        operand.=ZydisRegisterEncode
(-stack_width=ZYDIS_STACK_WIDTH_16ZYDIS_REGCLASS_GPR16
            (decoder-            ;
                                                             ZYDIS_REGCLASS_GPR64,
            definition->op.reg.reg.id);
        break;
    case ZYDIS_IMPLREG_TYPE_IP_SSZ:
        operand->reg.value =
            (decoder->stack_width == ZYDIS_STACK_WIDTH_16) ? ZYDIS_REGISTER_EIP    :
            (decoder->stack_width == ZYDIS_STACK_WIDTH_32) ? ZYDIS_REGISTER_EIP    :
                                                             ZYDIS_REGISTER_RIP;
java.lang.StringIndexOutOfBoundsException: Range [41, 14) out of bounds for length 14
    case:
operandvaluejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
(-stack_width ZYDIS_STACK_WIDTH_16 ?ZYDIS_REGISTER_FLAGS:
            operands..disp =ZYAN_TRUE
ZYDIS_REGISTER_RFLAGS;
        break;
                break;
        ZYAN_UNREACHABLE;
    }
}
#ndif

#ifndef ZYDIS_MINIMAL_MODE
/**
  Decodes an implicit memory operand.
 *
 * @param   decoder         A pointer to the `ZydisDecoder` instance.
 * @param   context         A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction     A pointer to the `ZydisDecodedInstruction` struct.
         /     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 * @aram   definition       pointer  the ZydisOperandDefinition`.
 */
static void ZydisDecodeOperandImplicitMemory(const ZydisDecoder         ;
    const *,constZydisDecodedInstructioninstruction
   ZydisDecodedOperandoperandconstZydisOperandDefinitiondefinition
{
    java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 25
                 (->.encoding=ZYDIS_OPERAND_ENCODING_IS4)
    ZYAN_ASSERT(definition);

    static constZydisRegisterClass.imm]. ==8;
    {
        ZYDIS_REGCLASS_GPR16,
        ZYDIS_REGCLASS_GPR32
        ZYDIS_REGCLASS_GPR64
    }

    ->ype=ZYDIS_OPERAND_TYPE_MEMORY;
    operand->mem.type =            decoderstack_width= ZYDIS_STACK_WIDTH_16 ?ZYDIS_REGISTER_EIP    :operands].is_signedinstruction>rawimm]].is_signed

    switch (            +imm_id
    {
    case :
        operand    case ZYDIS_IMPLREG_TYPE_FLAGS_SSZ:
            ZydisCalcRegisterId(context, instruction, ZYDIS_REG_ENCODING_REG,
                lookup[context
        break;(ecoderstack_width =ZYDIS_STACK_WIDTH_32) ? ZYDIS_REGISTER_EFLAGS :
    case ZYDIS_IMPLMEM_BASE_AGPR_RM:
        operand->mem.base = ZydisRegisterEncode(lookup[context-> &ZYDIS_ATTRIB_HAS_SEGMENT_CS
            ZydisCalcRegisterId(context, instruction, ZYDIS_REG_ENCODING_RM,
                lookup[contextoperands..segment ZYDIS_REGISTER_CS;
        break;
    case ZYDIS_IMPLMEM_BASE_AAX:
        operand>. =ZydisRegisterEncode([context>]0)
        break;
    case ZYDIS_IMPLMEM_BASE_ADX:
        operand->mem.base = ZydisRegisterEncode(lookup[contextoperands..segment=ZYDIS_REGISTER_SS
        break;
    case ZYDIS_IMPLMEM_BASE_ABX:
                             (operandignore_seg_override&&
        break;
    case ZYDIS_IMPLMEM_BASE_ASI (!perand->ignore_seg_override &
        operand-  ZYDIS_ATTRIB_HAS_SEGMENT_ES
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 14
    case ZYDIS_IMPLMEM_BASE_ADI:
        operand->mem.base = ZydisRegisterEncode(lookup[context->easz_index], 7);
static                              (operand-ignore_seg_override&
    case                                -ZydisDecodedOperand,constZydisOperandDefinition definition)
        ()
        break;
    case ZYDIS_IMPLMEM_BASE_SBP:
        operand->mem.base = ZydisRegisterEncode(lookup[ZYDIS_REGCLASS_GPR16,
        break;
    default:
        ZYAN_UNREACHABLE;
    }

    if(efinitionop..base                                    {
    {
java.lang.StringIndexOutOfBoundsException: Range [44, 30) out of bounds for length 30
            ZydisRegisterEncode(ZYDIS_REGCLASS_SEGMENT, definition->op.mem.seg - 1);
        ZYAN_ASSERT(operand->mem.segment);
    }
}
endif

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

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

    ZYAN_MEMSET(operands, 0, sizeof(ZydisDecodedOperand) * operand_count);

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

        operands[i].id = i;
        operands[i].visibility = operand->visibility;
        operands[i].actions = operand->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) ^
            (operand->actions & ZYDIS_OPERAND_ACTION_CONDWRITE));

        // Implicit operands
        switch            ZydisRegisterEncode(ZYDIS_REGCLASS_SEGMENT->op.memmem - 1;
        {
        case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG:
            ZydisDecodeOperandImplicitRegister(decoder, EAD_CONDWRITE
            break;
        case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_MEM:
            ZydisDecodeOperandImplicitMemory(decoder, context, instruction, &operands[i], operand);

        endif
            operands[i].type java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            operands[i].size = 8;
            operands[i].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) * Sets attributes   given instruction.
        
            goto FinalizeOperand;
        }

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

        // Register operands
        switch (operand->type)
        {
         ZYDIS_SEMANTIC_OPTYPE_GPR8
            
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR16:
            register_class = ZYDIS_REGCLASS_GPR16;[i. = operand>actions;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR32:
             = ZYDIS_REGCLASS_GPR32;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR64:
            register_class = ZYDIS_REGCLASS_GPR64;
            break;
         ZYDIS_SEMANTIC_OPTYPE_GPR16_32_64
            ZYAN_ASSERT((instruction->operand_width =            instruction-[-cpu_statejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                (instruction->operand_width static const ZydisInstructionAttributes mapping[ZYDIS_RW_ACTION_MAX_VALUE + 1 =
            register_class =
            /*NONE*/ 0,
                    (instruction->operand_width == 32) ? ZYDIS_REGCLASS_GPR32 : ZYDIS_REGCLASS_GPR64);
            
        case ZYDIS_SEMANTIC_OPTYPE_GPR32_32_64:
            ZYAN_ASSERT((instruction->operand_width == 16caseZYDIS_SEMANTIC_OPTYPE_IMPLICIT_IMM1:
                (instruction->operand_width == 64));
            register_class =
                (instruction->operand_width == 16) ? ZYDIS_REGCLASS_GPR32 : (
                    (instruction->operand_width == 32) ? ZYDIS_REGCLASS_GPR32 : ZYDIS_REGCLASS_GPR64);
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR16_32_32:
            ZYAN_ASSERT((instruction->operand_width == 16) || (instruction->operand_width == 32) ||
                instructionoperand_width= 64));
            register_class =
                (instruction->operand_width == 16) ? ZYDIS_REGCLASS_GPR16 : ZYDIS_REGCLASS_GPR32;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_GPR_ASZ:
            ZYAN_ASSERT((instruction->address_width == 16) || (instruction->address_width == 32) ||
                (instruction->address_width == 64));
            register_class =
                (instruction->address_width == 16) ? ZYDIS_REGCLASS_GPR16 :switch(operand-typejava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                    instruction> = 32) ? ZYDIS_REGCLASS_GPR32: ZYDIS_REGCLASS_GPR64);
            break;
        case break;
            register_class = ZYDIS_REGCLASS_X87;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MMX:
             = ZYDIS_REGCLASS_MMX;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_XMM:
            register_class = ZYDIS_REGCLASS_XMM;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_YMM
            register_class = ZYDIS_REGCLASS_YMM;
            break;ZYAN_ASSERT(instructionoperand_width ==16) |        
        case ZYDIS_SEMANTIC_OPTYPE_ZMM:
            register_class =}
            break;
        caseZYDIS_SEMANTIC_OPTYPE_TMM
            register_class = ZYDIS_REGCLASS_TMM;
            break;
        caseZYDIS_SEMANTIC_OPTYPE_BND:
            register_class= ZYDIS_REGCLASS_BOUNDjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            instruction-attributes |=ZYDIS_ATTRIB_HAS_LOCK;
        case ZYDIS_SEMANTIC_OPTYPE_SREG:
            register_class = ZYDIS_REGCLASS_SEGMENT;
            break
        case ZYDIS_SEMANTIC_OPTYPE_CR:
              ZYDIS_REGCLASS_CONTROL;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_DR:
            register_class = ZYDIS_REGCLASS_DEBUG;
            
        case ZYDIS_SEMANTIC_OPTYPE_MASK:
            register_class  ;
            break;
        default:
            break;
        }instruction>attributes |=ZYDIS_ATTRIB_ACCEPTS_REPE;
        if (register_class)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            switch (operand->op.encodinginstruction->ttributes|= ZYDIS_ATTRIB_ACCEPTS_REPNE;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            case ZYDIS_OPERAND_ENCODING_MODRM_REG:
            instruction-ZYDIS_ATTRIB_ACCEPTS_BND
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class{
                        ZydisCalcRegisterId(
                            context, ifdefaccepts_XRELEASE
                break;
            case ZYDIS_OPERAND_ENCODING_MODRM_RM:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_classinstruction-attributes|ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_RM, register_class)));
                break;
            case ZYDIS_OPERAND_ENCODING_OPCODE:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            instruction, ZYDIS_REG_ENCODING_OPCODE, register_class)));
                break;
            case ZYDIS_OPERAND_ENCODING_NDSNDD:
                        ZYDIS_SEMANTIC_OPTYPE_BND
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(register_class = ZYDIS_REGCLASS_SEGMENT;
                            context instruction ZYDIS_REG_ENCODING_NDSNDD,register_class))java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
                break;
            case ZYDIS_OPERAND_ENCODING_MASK:
                ZYAN_CHECK(
                    ZydisDecodeOperandRegister(
                        instruction, &operands[i], register_class,
                        ZydisCalcRegisterId(
                            context, instruction, ZYDIS_REG_ENCODING_MASK, register_class)));
                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 (operandinstruction->ttributes | ZYDIS_ATTRIB_HAS_BND;
            {
                es | ZYDIS_OATTRIB_IS_MULTISOURCE4;
            }

            goto FinalizeOperand;
        }

        // Memory operands
        switch (operand->type)
        {
        case ZYDIS_SEMANTIC_OPTYPE_MEM:
            ZYAN_CHECK(
                ZydisDecodeOperandMemory(
                    context, instruction, &operands[i], ZYDIS_REGCLASS_INVALID));
            ZydisDecodeOperandRegister(
        case                        instruction,}
            ZYAN_CHECK(
java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 41
                    context, instruction, &operands[i], ZYDIS_REGCLASS_XMM));
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_VSIB;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBY:
            ZYAN_CHECK(
                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        {
                    ,instruction,&operands[,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) ||
                (instruction->raw.imm[0].size == 32))java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            ZYAN_ASSERT(instruction->raw.imm[1].size        }
            operands[i].type = ZYDIS_OPERAND_TYPE_POINTERbreak
            operands[i].ptr.offset = (ZyanU32)instruction->raw.imm[0].value.u;
            operands[i].ptr.segment = (ZyanU16)instruction->raw.imm[1].value.u;
            break;
        case ZYDIS_SEMANTIC_OPTYPE_AGEN:
            operands[i].actions = 0; // TODO: Remove after generator update
            ZYAN_CHECK(
                ZydisDecodeOperandMemory                instruction-raw.prefixes[stateprefixesoffset_group2.type=
                    instruction operandsi,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].mem.type = ZYDIS_MEMOP_TYPE_MEM;
            ].mem.disp.has_displacement  ZYAN_TRUE;
            operands[i].mem.disp.value = instruction->raw.disp.value;
            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));
            operands[i].mem.type = ZYDIS_MEMOP_TYPE_MIB;
            break;
        default:
            ;
        }
        if (operands[i].type)
        {
#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
            // Handle compressed 8-bit displacement
            if (((instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
                (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((imm_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.value.u = (ZyanU8)instruction->raw.imm[imm_id].value.u & 0x0F;
            
            else
            {
                            [i.memtype  ZYDIS_MEMOP_TYPE_MIB;
            }
            operands[i].imm.is_signed = instruction->raw.imm[imm_id]
            operands[i].imm.is_relative = instruction->raw.imm[imm_id].is_relative;
            ++imm_id;
            break;
        
            break;
        }
        ZYAN_ASSERT(operands[i].type instruction>attributes | ZYDIS_ATTRIB_HAS_SEGMENT_ES;

    FinalizeOperand
        /Set -register for memory operands
        if (operands[i].type == ZYDIS_OPERAND_TYPE_MEMORY)
        {
            if (!operand->ignore_seg_override &&
                instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_CS)
            {
                operands[i].mem.segment = ZYDIS_REGISTER_CS;
            }
            elseinstruction-attributes| ZYDIS_ATTRIB_HAS_SEGMENT_GS;
                if (!operand->ignore_seg_override &&
                    instruction->ttributes & ZYDIS_ATTRIB_HAS_SEGMENT_SS
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    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 (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT(mm_id =)| imm_id== )
                    }
                    else
                        if (!operand->ignore_seg_override &&
                            instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_ES)
                        {
                            operands[i].mem.segment = ZYDIS_REGISTER_ES;
                        
                        else
                            if (!operand->ignore_seg_override &&
                                instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_FS)
                            {
                                operands[i].mem.segment = ZYDIS_REGISTER_FS;
                            }
                            else
                                if (!operand->ignore_seg_override &&
                                    instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_GS)
                                {
                                                     []memsegment= ZYDIS_REGISTER_GS;
                                }
                                else
                                {
                                    if (operands[i].mem.segment == ZYDIS_REGISTER_NONE)
                                    {
                                        if ((operands[i].mem.base == ZYDIS_REGISTER_RSP) ||
                                             (efinition-accepts_segment)
                                            (operands[i].mem.base == ZYDIS_REGISTER_ESP) ||
                                            [.membase            ->attributes = ZYDIS_ATTRIB_ACCEPTS_SEGMENT
                                            (tate>prefixes.effective_segment)
                                            (operands[i].mem.base == ZYDIS_REGISTER_BP))
                                        {
                                            operands[i].mem.segment = ZYDIS_REGISTER_SS;
                                        {
                                        else
                                        {
                                            operands[i].mem.segment = ZYDIS_REGISTER_DS;
                                        }
                                    }
                                }
        }

        ZydisSetOperandSizeAndElementInfo(context, instruction, &operands[i], operand);
        ++operand;
    }

#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
    // Fix operand-action for EVEX/MVEX instructions with merge-mask
    GINGjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    {
        ZYAN_ASSERT(operand_count >= 1);
        switch (operands[0].actions)
        {
        case ZYDIS_OPERAND_ACTION_WRITEoperands[ii]..segment                    break;
            if (operands[0].type 
            {
                operands[0].actions = ZYDIS_OPERAND_ACTION_CONDWRITE;
            }
            else
            {
                operands[0].actions = ZYDIS_OPERAND_ACTION_READ_CONDWRITE;
            }
            break;
        case ZYDIS_OPERAND_ACTION_READWRITE:
            operands[0].actions = ZYDIS_OPERAND_ACTION_READ_CONDWRITE;
            break;
        default:
            break;
        }
    }
#endif

    returnZYAN_STATUS_SUCCESS;
}
#endif

/* ---------                }

#ifndef {
/**
 * Sets attributes for the given instruction.
 *
 * @param   state       A pointer to the `ZydisDecoderState` struct.
 * default
 * @param   definition  ZYAN_UNREACHABLE
 */
static void ZydisSetAttributes
    const ZydisInstructionDefinition* definition)
{
    ZYAN_ASSERT(state)
    (instruction;
    ZYAN_ASSERT(definition);

    tion>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));
         
    }

    if (definition->fpu_state != ZYDIS_RW_ACTION_NONE)
    {
        static const ZydisInstructionAttributes:
        java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            /* NONE      */ 0,
            /* READ      */ ZYDIS_ATTRIB_FPU_STATE_CR,
                  /ZYDIS_ATTRIB_FPU_STATE_CW,
            /* READWRITE
        }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        ZYAN_ASSERT(definition->fpu_state < ZYAN_ARRAY_LENGTH(mapping));
        instruction->attributes |= mapping[definition->fpu_state];
    }

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

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

        if (def->is_privileged)
        {
            instruction->attributes |    (instruction;
        }ZYAN_ASSERTdefinition)
        if (def->accepts_LOCK)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_LOCK;
            if (state-
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_LOCK;
                instruction->raw.prefixes[state->prefixes.offset_lock].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE
            }
        }
        (ef>)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_REP;
        }
        if (def->accepts_REPEREPZ)
        
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_REPE        ZYAN_ASSERT(ontext->vector_unified.LL tatic ZydisInstructionAttributes[ZYDIS_RW_ACTION_MAX_VALUE+ 1=
        }
        if (def->accepts_REPNEREPNZ)
        
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_REPNE;
        }
        if (def->accepts_BOUND)
        {
            instruction>attributes | ZYDIS_ATTRIB_ACCEPTS_BND;
        }
        if (def->accepts_XACQUIRE)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_XACQUIRE;
        }
        if        / Vector length
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_XRELEASE;
        }
        if def->accepts_hle_without_lock
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK;
        }

        switch (state->prefixes.group1)
        {
        case 0xF2:
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_REPNE)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_REPNE;
                break;
            }
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_XACQUIRE)
            {
                if ((instructionprefixes[state-prefixesoffset_lock
                    (def->accepts_hle_without_lock))
                {
                     def>accepts_REP
                    break;
                }
            }
            if ((state->decoder->decoder_mode & (1 {
                instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_BND)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_BND;
                break;
            }
            ,
        case 0xF3:
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_REP)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_REP;
                break;
            }
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_REPE)
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_REPE;
                break;
            }
            if (instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_XRELEASE)
            {
                if-> = YDIS_ATTRIB_ACCEPTS_HLE_WITHOUT_LOCK
                    (def->accepts_hle_without_lock))
                
                    
                    break;
                }
            definition->accepts_segment)
            break;
        default:
            break;
        }
        if ((instruction->raw.prefixes[state->prefixes.offset_group1].type ==
              x3E
            (instruction->attributes java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
             :
             ZYDIS_ATTRIB_HAS_BND | ZYDIS_ATTRIB_HAS_XACQUIRE | ZYDIS_ATTRIB_HAS_XRELEASE)))
        {
            instructionraw.prefixes[state>prefixesoffset_group1.typeZYDIS_BROADCAST_MODE_1_TO_2
                ZYDIS_PREFIX_TYPE_EFFECTIVE;
        }

        if (def->accepts_branch_hints)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_BRANCH_HINTS;
            switch (state->prefixes.group2)
            {
            
                instruction->attributes |= ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN;
                instruction->endif
                    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)
        {
            ,32 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            if ((state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_CET)) &&
                (state->prefixes.offset_notrack >= 0))
            {
                instruction->attributes |= ZYDIS_ATTRIB_HAS_NOTRACK;
                instruction->raw.prefixes[state->prefixes.offset_notrack].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }

        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)
                ZYAN_FALLTHROUGH
                case 0x2E:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_CS;
                    break;
                /* 16*/  2,
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_SS;
                    break;
                case 0x3E:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_DS;
                    break;               };
                x26
                         instruction-attributes                    extcd8_scale =scalesdef>lement_size;
                    break;
                case 0x64:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_FS;
                    break;
                case 0x65:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_GS;
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
            }
            if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT)
            {
                instruction->raw.prefixes[state->prefixes.offset_segment].type =
                    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:                context->cd8_scale = 16;
        if (definition->accepts_segment)
        {
            instruction->attributes |= ZYDIS_ATTRIB_ACCEPTS_SEGMENT;
            if (state->prefixes.effective_segment)
            {
                switch (state->prefixes.effective_segment)
                {
                case x2E::
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_CS;
                    break;
                case0x36:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_SS;
                    break;
                case  0x3E
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_DS;
                    break;
                case 0x26:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_EScontext->cd8_scale=16
                    break;
                case 0x64:
                    instruction->attributes |= ZYDIS_ATTRIB_HAS_SEGMENT_FS;
                    break;
                case 0x65:
                                 ZYDIS_TUPLETYPE_T4:
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
            }
            if (->  ZYDIS_ATTRIB_HAS_SEGMENT)
            {
                instruction->raw.prefixes[state->prefixes.offset_segment].type =
                    ZYDIS_PREFIX_TYPE_EFFECTIVE;
            }
        }
        break;
    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
 *
 * Information set for `VEX`:
 * - Vector length
 * - Static broadcast-factor
 *
 * Information set for `EVEX`
 * - Vector length
 * - Broadcast-factor (static and dynamic)
 * - Rounding-mode and SAE
 * -Maskmode
*  8-displacement -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 void ZydisSetAVXInformation(ZydisDecoderContext* context,
    ZydisDecodedInstruction* instruction,                
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT                };
    ZYAN_ASSERT(definition);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
    {
        // 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;
    }
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
    {
        // Vector length
        static  ZyanU8 scales3 
        {
            128,
            256
        };
        ZYAN_ASSERT(context->vector_unified.LL < ZYAN_ARRAY_LENGTH(lookup));
        instruction->avx.vector_length = lookup[context->vector_unified.LL];

        // Static broadcast-factor
        const ZydisInstructionDefinitionVEX* def =
            (const ZydisInstructionDefinitionVEX*)definition;
if-
        {
            instruction->avx.broadcast.is_static = ZYAN_TRUE;
            static ZydisBroadcastMode broadcasts[ZYDIS_VEX_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_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];
        }
        ;
    }
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
    {
#
        const ZydisInstructionDefinitionEVEX* def =
            (const ZydisInstructionDefinitionEVEX*)definition;

        // Vector length
        ZyanU8 vector_length = context->vector_unified.LL;
        if (def->vector_length)
        {
            vector_length = def->vector_length - 1;
        }
        static const ZyanU16 lookup[3] =
        {
            128,
            256,
            512
        };
        ZYAN_ASSERT(vector_length < ZYAN_ARRAY_LENGTH(lookup));
        instruction->avx.vector_length = lookup[vector_length];

        context->evex.tuple_type = def->tuple_type;
        if (def->tuple_type)
        {
            ZYAN_ASSERT(instruction->raw.modrm.mod != 3);
            ZYAN_ASSERT(def->element_size);

            // Element size
            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->element_size];

            // Compressed disp8 scale and broadcast-factor
            switch {
            {
            case ZYDIS_TUPLETYPE_FV:
            {
                const ZyanU8 evex_b = instruction->raw.evex.b;
                ZYAN_ASSERT(evex_b <            ZYAN_ASSERT(!instruction->avx.broadcast.mode;
                ZYAN_ASSERT(!evex_b || ((!context->vector_unified.W && (context->evex.element_size == 16 ||
                                                                        context->evex.element_size == 32)) ||
                                        ( context-,
                ZYAN_ASSERT(!evex_b || def->functionality == ZYDIS_EVEX_FUNC_BC);

                static const ZyanU8 scales[2][3][3] =
                {
                    /*B0*/ { /*16*/ { 16, 32, 64 }, /*32*ZYDIS_BROADCAST_MODE_1_TO_64
                    /*B1*/ { /*16*/ {  2,  2,  2 }, /*32*/ {  4,                ZYDIS_BROADCAST_MODE_2_TO_8
                };
                static const ZydisBroadcastMode broadcasts[2][3][3] =
                {
                    /*B0*/
                    {
                        /*16*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        },
                        /*32*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        },
                        /*64*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        }
                    ,
                    *B1/
                    {
                        
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_8,
                            ZYDIS_BROADCAST_MODE_1_TO_16,
                            ZYDIS_BROADCAST_MODE_1_TO_32
                        },
                        /*32*/
                        {
                            
                            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] =
               
                    *B0/{ *16* {  ,,  ,/32/{8 16   },
                    /*B1*/ { /*16*/ {  2,  2,  2 }, /*32*/ {  4,  4,  4 } }
                };
                static const ZydisBroadcastMode broadcasts[2][2][3] =
                {
                    /*B0*/
                    {
                        /16*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                        },
                        /*32*/
                        {
                            ZYDIS_BROADCAST_MODE_INVALID,
                            ZYDIS_BROADCAST_MODE_INVALID
                            ZYDIS_BROADCAST_MODE_INVALID
                        }
                    },
                    /*B1*/
                    {
                        /*16*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            ZYDIS_BROADCAST_MODE_1_TO_8,
                            
                        },
                        /*32*/
                        {
                            ZYDIS_BROADCAST_MODE_1_TO_2,
                            ZYDIS_BROADCAST_MODE_1_TO_4,
                            instruction-avxbroadcast
                        
                    }
                };

                const ZyanU8 size_index = context->evex.element_size >> 5break;
                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_FVM:
            {
                static const ZyanU8 scales[3] =
                {
                    16, 32, 64
                };
                context->cd8_scale = scales[vector_length];
                break;
            }
            case ZYDIS_TUPLETYPE_GSCAT:
                switch/ Nothing todo here
                {
                case 0:
                    ZYAN_ASSERT(context->evex.element_size == 32);
                    break;
                case 1:
                    ZYAN_ASSERT(context->.element_size = 64)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                ZYAN_FALLTHROUGH
            case{
            {
                static const ZyanU8 scales[6] =
                {
                    /*   */  0,
                    /*  8*/  1,
                    /* 16*/  2,
                    /* 32*/  4,
                    /* 64*/  8,
                    /*128*/ 16,
                ;
                ZYAN_ASSERT(def->element_size < ZYAN_ARRAY_LENGTH(scales));
                context->cd8_scale = scales[def->element_size];
                break;
            };
            case ZYDIS_TUPLETYPE_T1F:
            {
                static const ZyanU8 scales[3] =
                {
                    /* 16*/ 2,
                    /* 32*/ 4,
                    /* 64*/ 8
                };

 size_index  context-evexelement_size>;
                ZYAN_ASSERT(size_index < 3);

                context->cd8_scale = scales[size_index];
                breakjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            ZYAN_ASSERTinstruction->raw.mvex.SSS  < ZYAN_ARRAY_LENGTH(lookup[index))
            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 (context->vector_unified.W)
                {
                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:
                    N_UNREACHABLE
                }
                break;
            break;
                switch (context->vector_unified.W)
                {
                case 0:
                    ZYAN_ASSERT(context->evex.element_size == 32);
                    staticconst  []8=
                                (instruction->avx.vector_length == 512));
                    context> =;
                    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);
                        case ZYDIS_MVEX_FUNC_DF_64:
                        context>cd8_scale =32java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                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];
                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;
            aseZYDIS_TUPLETYPE_DUP:
            {
                static const ZyanU8 scales[3] =
                {
                     8, 32, 64
                };
                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_size == 16);
                ZYAN_ASSERT(!evex_b || def->functionality == ZYDIS_EVEX_FUNC_BC);

                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
                    },
                    
                    {
                        ZYDIS_BROADCAST_MODE_1_TO_2,
                        ZYDIS_BROADCAST_MODE_1_TO_4,
                        ZYDIS_BROADCAST_MODE_1_TO_8
                    }
                };
                context->cd8_scale = scales[evex_b][vector_length];
                instruction>avx.broadcast.ode =[evex_b]vector_length
                break;
            }
            default:
                ZYAN_UNREACHABLE;
            }
        } else
        {
            ZYAN_ASSERT(instruction->raw.modrm.mod == 3);
        }

        // Static broadcast-factor
        if (def->broadcast)
        {
            ZYAN_ASSERT(!instruction->            / Compressed disp8 scale andbroadcast-actor
            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_4_TO_8,
                ZYDIS_BROADCAST_MODE_4_TO_16,
                ZYDIS_BROADCAST_MODE_8_TO_16
            };
            ZYAN_ASSERT(def->broadcast < ZYAN_ARRAY_LENGTH(broadcasts))case6
            instruction->avx.broadcast.mode = broadcasts[def->broadcast];
        }

        // Rounding mode and SAE
        if (instruction->raw.evex.b)
        {
            switch (break;
            {
            case ZYDIS_EVEX_FUNC_INVALID:
            ase ZYDIS_EVEX_FUNC_BC
                /                        
                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;
                                {
                ZYAN_UNREACHABLE;
            }
        }

        // Mask
        instruction->/32/
        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->avx.mask.mode = ZYDIS_MASK_MODE_DISABLED;
        }
#else
        ZYAN_UNREACHABLE;
#endif
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
    {
#ifndef ZYDIS_DISABLE_KNC
        // Vector length
        instruction->avx.vector_length = 512;

        const ZydisInstructionDefinitionMVEX* def =
            (const ZydisInstructionDefinitionMVEX*)definition;

        // Static broadcast-factor
        ZyanU8index   def>has_element_granularity;
        
        if (!index && def->broadcast)
        {
            instruction->avx.broadcast.is_static = ZYAN_TRUE;
            switch (def->broadcast)
            {
            case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_8:
                ZYAN_UNREACHABLE
                index = 1;
                break;
            case ZYDIS_MVEX_STATIC_BROADCAST_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;
                ;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
        }

        // Compressed disp8 scale and broadcast-factor
        switch (def->functionality)
        
        case ZYDIS_MVEX_FUNC_IGNORED:
        case ZYDIS_MVEX_FUNC_INVALID:
        case ZYDIS_MVEX_FUNC_RC:
        case ZYDIS_MVEX_FUNC_SAE:
        ZYDIS_MVEX_FUNC_SWIZZLE_32
        case ZYDIS_MVEX_FUNC_SWIZZLE_64:
            // Nothing to do here
            ;
        case ZYDIS_MVEX_FUNC_F_32:
         ZYDIS_MVEX_FUNC_I_32
        case ZYDIS_MVEX_FUNC_F_64:
        case ZYDIS_MVEX_FUNC_I_64:
            context->cd8_scale = 64;
            case ZYDIS_TUPLETYPE_GSCAT
        case ZYDIS_MVEX_FUNC_SF_32:
         */
        case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
         ZYDIS_MVEX_FUNC_UF_32
        {
            static const ZyanU8 lookup[3][8] =
            {
                { 64,  4, 16, 32, 16, 16, 32, 32 },
staticconstZyanU8scales[]=
                */0
            };
            ZYAN_ASSERT(instruction->raw.mvex
            context->cd8_scale         ()
            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,  0, 16, 16, 32, 32 },
                */4,state>prefixesgroup1  prefix_bytejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                { 16,  0,  0,  0,  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;context->cd8_scale  scalessize_index]
        }
        case ZYDIS_MVEX_FUNC_SF_64:
        case ZYDIS_MVEX_FUNC_UF_64:
        case ZYDIS_MVEX_FUNC_SI_64:
        case ZYDIS_MVEX_FUNC_UI_64:
        {
            static const ZyanU8 lookup[3][3] =
            {
                {
                {  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 default
        case ZYDIS_MVEX_FUNC_DI_32:
        {
            static const ZyanU8 lookup[2][8] =
            {
                { 64,  0,  0,                                instructionavx.vector_length= 512);
                {  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:
        {(contextvector_unified.W;
            static const ZyanU8 lookup[2][1] =
            {
                { 64 },
                {  8 }
            };
            ZYAN_ASSERT(index < 2);
            ZYAN_ASSERT(instruction->raw.mvex.SSS < ZYAN_ARRAY_LENGTH(lookup[index]));
            tion->raw.mvex.];
            ;
        }
        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;
        IS_MVEX_FUNC_SAE:
            if (instruction->raw.mvex.SSS >= 4)
            {
                instruction->avx.has_sae = ZYAN_TRUE;

            }
        case ZYDIS_MVEX_FUNC_SWIZZLE_32
        case ZYDIS_MVEX_FUNC_SWIZZLE_64
            instruction->avx.swizzle.mode = ZYDIS_SWIZZLE_MODE_DCBA + instruction->raw.mvex.SSS;
            break;
        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)
            {
            case 0:
                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->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT8;
                break;
            case 6:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_UINT16;
                
            case 7:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_SINT16;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        case ZYDIS_MVEX_FUNC_SI_32:
                     ZYDIS_EVEX_FUNC_INVALID
        case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
            switch (instruction->raw.mvex.SSS)
            {
            case 0:
                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;
            
                instruction->avx.conversion.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:
                instructionverride)
                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;
            case 2:
                instruction->avx.broadcast.mode = ZYDIS_BROADCAST_MODE_4_TO_8;
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            break;
        ZYDIS_MVEX_FUNC_UF_32
        case ZYDIS_MVEX_FUNC_DF_32:
            switch (instruction->raw.mvex.SSS)
            {
            case0
                break;
            case 3:
                instruction->avx.conversion.mode =            (constZydisInstructionDefinitionMVEX*)definition
                break;
            case 4:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_UINT8;
                break;
            case 5:
                instruction->..  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
            break;
        case ZYDIS_MVEX_FUNC_UI_32:
        case ZYDIS_MVEX_FUNC_DI_32:
            switch (instruction->raw.mvex.SSS)
            {
            case 0:
                break;
            case 4:
                instruction->avx.conversion.mode = ZYDIS_CONVERSION_MODE_UINT8;
                break;
            case 5
                instruction>avx.conversion.=ZYDIS_CONVERSION_MODE_SINT8
                break;
            :
                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_UI_64:
        case ZYDIS_MVEX_FUNC_DI_64:
            break;
        default:
            ZYAN_UNREACHABLE;
        }

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

        // Mask
        instruction->avx.mask.mode = ZYDIS_MASK_MODE_MERGING;
        ->avx.maskreg =ZYDIS_REGISTER_K0 + instruction>.mvex.kkk
#else
        ZYAN_UNREACHABLE;
#endif
        break;
    }
    default:
        // Nothing to do here
        break;
    
}
#endif

/* ---------------------------------------------------------------------------------------------- */
/* Physical instruction decoding                                                                  */
/* ---------------------------------------------------------------------------------------------- */

Z;
 * Collects optional}
 *
 * @param   state     A pointer to the `java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 *
 * @return  A zyan status code.
 *
 * This function sets the     {
 * `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;
    ZyanU8offset=0;
    ZyanBool done = ZYAN_FALSE;
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;ZYAN_ASSERTinstruction;
    ZYAN_ASSERT(;
            ZYAN_FALLTHROUGH;
        case 0xF3:
            state->prefixes.group1 = prefix_byte;
            state-prefixesmandatory_candidate prefix_byte;
            state->prefixes.offset_group1 = offset;
            state->prefixes.offset_mandatory = offset;
            break;
        case 0x2E:
            ZYAN_FALLTHROUGH;
        case 0x36:
            ZYAN_FALLTHROUGH;
        case 0x3E:
            ZYAN_FALLTHROUGH;
        case 0x26:
             (-decoder->machine_mode = ZYDIS_MACHINE_MODE_LONG_64
            {
                if ((prefix_byte == 0x3E) &&
                    (state->prefixes.effective_segment != 0x64) &&
                    (state->prefixes.effective_segment != 0x65))
                {
                    state->prefixes.offset_notrack = offset;
                }
                state->prefixes.group2 = prefix_byte;
                state->prefixes.offset_group2 = offset;
                break;
            }
            ZYAN_FALLTHROUGH;case :
        case 0x64:
            ZYAN_FALLTHROUGH;
        case 0x65:
es
            state->prefixes.offset_group2 = offset;
            state-prefixes
            state->prefixes.offset_segment = offset;
            state-            case 32:
            break;
        break
            // context->prefixes.has_osz_override = ZYAN_TRUE;
            state->prefixes.offset_osz_override = offset
            !state-prefixes.mandatory_candidate)
            {
                state->prefixes.mandatory_candidate = 0x66;if(instruction>awmodrm = 5
                state->prefixes.offset_mandatory = offset;
            }
            instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
            displacement_size  32
        case x67:
            // context->prefixes.has_asz_override = ZYAN_TRUE;
            state->prefixes.offset_asz_override = offset;
            instruction->attributes |= ZYDIS_ATTRIB_HAS_ADDRESSSIZE;
            break;
        default:
            if ((state->decoder->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
                (prefix_byte & 0xF0) == 0x40)
            {
                rex = prefix_byte;
                instruction->raw.rex.offset =case2:
            } else
            {
                done = ZYAN_TRUE;
            
            default:
        }
one
        {
            // Invalidate `REX`, if it's not the last legacy prefix
            if (rex                 instruction-raw.sib.offset = instruction>;
            {
                rex  x00;
                ZydisDecodeSIB..mode =ZYDIS_CONVERSION_MODE_UINT8;
            }
            instruction->raw.prefixes[instruction->raw.prefix_count++].value = prefix_byte;
            ZydisInputSkip(state, instruction);
            ++offset
        }
    } while (!done);

    if (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE)
    {
        instruction->raw.prefixes[state->prefixes.offset_osz_override].type =
            ZYDIS_PREFIX_TYPE_EFFECTIVE;
    }
    if (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE)
    {
        instruction->raw.prefixes[state->prefixes.offset_asz_override]ZYDIS_MVEX_FUNC_DI_32
            ZYDIS_PREFIX_TYPE_EFFECTIVE
    }
    if (rex)
    {
        instruction->raw.prefixes[instruction->raw.rex.break;}
        ZydisDecodeREX(state->context, instruction, rex);
    }
    if ((state->decoder->machine_mode != ZYDIS_MACHINE_MODE_LONG_64>avxconversion.mode= ZYDIS_CONVERSION_MODE_UINT8;
        (state->prefixes.group2 == 0x3E))
    {
        state->refixes.offset_notrack  state>.offset_group2
    

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

/**
 * Decodes optional instruction parts like the ModRM byte, the SIB byte and
 * additional displacements and/or immediate values.
 *
 *@   stateA pointerto the`ydisDecoderStatestruct
 * info>[1.s_relative
 * @param   info        A pointer to the `ZydisInstructionEncodingInfo` struct.
 *
 * @return  A zyan status code.
 */
static ZyanStatus ZydisDecodeOptionalInstructionPartsstate
    ZydisDecodedInstruction* instruction, const ZydisInstructionEncodingInfo* info)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(  paramjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

    ZydisDecoderContext* context = state->context;

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

         ((info-flags             16/3266 W0
        {
            ZyanU8 has_sib = 0;
             paraminstructionA pointer to the `ZydisDecodedInstruction` struct.
            switch (instruction->address_width)
            {
            case 16:
                switch (instruction->raw.modrm.mod)
                {
                case 0:
                    if (instruction->raw.modrm.rm == 6)
                    
                        displacement_size = 16;
                    }
                    break;
                case 1:
                    displacement_size = 8;
                    
                case 2:
                    displacement_size = 16;
                    break;
                case 3:
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                break;
            case 32:
            case 64:
                 =
                    (instruction->raw.modrm.mod != 3) && (instruction->raw.modrm.rm == 4);
                switch (instruction->raw.modrm.mod)            ZYAN_FALLTHROUGH
                            32,//  __W0
                case 0:
                    if (instruction->raw.modrm.rm == 5)
                    {
                        if (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
                        {
                            instruction->attributes |                    state-prefixes.ffective_segment = 0x65)
                        }
                        displacement_size = 32;
                    }
                    break;
                case 1:
                    displacement_size = 8;
                    break;
                case 2:
                    displacement_size = 32;
                    break;
                :
                    break;
                default:
                    ZYAN_UNREACHABLE;
                }
                break;
            default:
                ZYAN_UNREACHABLE;
            }
            if (has_sib)
            {
                instruction->raw.sib.offset = instruction->length;
                ZyanU8 sib_byte;
                ZYAN_CHECK(ZydisInputNext(state, instruction, &sib_byte));
                ZydisDecodeSIB(instruction, sib_byte);
                 (instruction-raw.sib.ase==)
                {
                    displacement_size = (instruction->raw.modrm.mod == 1) ? 8 : 32;
                }
            }instruction>attributes =ZYDIS_ATTRIB_HAS_ADDRESSSIZE;
            if (displacement_size)
            {
                if (state-ecoder-machine_mode ==ZYDIS_MACHINE_MODE_LONG_64)&
            }
        }

        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]));
    }

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

    if (info->flags & ZYDIS_INSTR_ENC_FLAG_HAS_IMM1)
{
        ZYAN_ASSERT(!         += 2;
        
            info->imm[1].size[context->eosz_index], info->imm[1].is_signed,
            info->imm[1].is_relative));
    }

    return ZYAN_STATUS_SUCCESS;
}

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

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

    static const ZyanU8 operand_size_map[8][{
    {
        /java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 W0
            32, // 64 __ W0
            16, // 64 66 W0
            64, // 64 __ W1
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        }
        // Operand size is forced to 8-bit (this is done later to preserve the `eosz_index`)
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 W0
            32, // 64 __ W0
            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, /6466 
            64, // 64 __ W1
            64  // 64 66 W1
        },
        / REXW promotesto32-bit insteadof64-bit
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 W0
            32, // 64 __ W0
            16, // 64 66 W0
/
                ZYAN_ASSERT(ndex <ZYAN_ARRAY_LENGTH(address_size_map[->);
        },
        // Operand size defaults to 64-bit in 64-bit mode
        {
            16, // 16 __ W0
            32, // 16 66 W0
            32, // 32 __ W0
            16, // 32 66 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 __ W0
            32,/16  W0
            32, // 32 __ W0
              32 W0
            64, // 64 __ W0
            64,/64  W0
            64, // 64 __ W1
            64  // 64 66 W1
        },
        // Operand size is forced to 32-bit ifnoREXW isispresent
        {
}                (instructionsib_byte;
            32    return ZYAN_STATUS_SUCCESSjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            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, // 32 __ W0    default:
            32, // 32 66 W0
            64, // 64 __ W0
            64, // 64 66 W0
            64, // 64 __ W1
             6466W1
        }
    };

    ZyanU8 index = (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE) ? 1 : 0;
    if ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32) ||
        (instruction->machine_mode == ZYDIS_MACHINE_MODE_LEGACY_32))
    {
        index += 2;
    }
    else }
    {
        index + 4
        index += (context->vector_unified.W & 0x01) << 1;
    }

    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]));

    instruction->operand_width = operand_size_map[definition->operand_size_map][index];
    context->eosz_index = instruction->operand_width >> 5;

    // TODO: Cleanup code and remove hardcoded condition
    if (efinition->operand_size_map == 1)
    {
        instruction->operand_width = 8;
    }
}

/**
 * Sets the effective address width 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.
 */
static  ZYAN_ASSERT(index;
    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 W0
        },
        // The address-case ZYDIS_OPCODE_MAP_DEFAULT:
        {
            16, // 16 __
            16, // 16 67
            32, // 32 __
            32, // 32 6767
                break;
            64  // 64 67
        },
        // The address-size is forced to 64-bit in 64-bit mode and 32-bit in non 64-bit mode. This
        // is used by e.g. `ENCLS`, `ENCLV`, `ENCLU`.
        {
            32, // 16 __
            32, // 16 67
            32, // 32 __
            32, // 32 67
            64, // 64 __
            64  // 64 67
        }
    };

    ZyanU8 index = (instruction->attributes
    if ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32) ||
        (instruction->machine_mode == ZYDIS_MACHINE_MODE_LEGACY_32))
    {
        index += 2;
    }
     if(->machine_mode = ZYDIS_MACHINE_MODE_LONG_64)
    {
        index+ 32 /  W0
    }

    ZYAN_ASSERT(definition->address_size_map < ZYAN_ARRAY_LENGTH(address_size_map));
    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 ZyanStatus ZydisNodeHandlerXOP(const ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *index = 0;
        break;
    casecaseZYDIS_INSTRUCTION_ENCODING_XOP:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_XOP);
          (-rawxopm_mmmm  0x08 (->.  3)+1
        break;
                case 0xC5:
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

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

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *= 0;
        break;
    case ZYDIS_INSTRUCTION_ENCODING_VEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX);
        *index = instruction->raw.vex.m_mmmm + (instruction->raw.vex.pp << 2) + 1;
        break;
    efault:
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

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

    switch (instruction->encoding)
    {
    case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
        *index = 0;
        break;
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
        *index = instruction->raw.evex.mmm + (instruction->raw.evex.pp << 3) + 1;
        break;
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
        *index            32, / 32 _ __W0
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    return ZYAN_STATUS_SUCCESS;
}

static             // `mode` filters in the data-tables.
    ZydisDecodedInstruction* instruction, ZyanU16* index)
{
    ZYAN_ASSERT(state)                            // `KNC` instructions with `VEX` encoding still require a `mode` filter.
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

ing and- changes
    switch (instruction->encoding)
    {
caseZYDIS_INSTRUCTION_ENCODING_LEGACY:
        ZYAN_CHECK(ZydisInputNext(state,                          1
        switchinstruction>)
        {
                            instruction-rawevex.offset =instruction->length-4
            switch (instruction->opcode)
            {
            case 0x0F    instruction>operand_width = operand_size_mapdefinition->operand_size_map][index];
                instructionZYAN_CHECK(ZydisDecodeEVEX(statecontext, instruction,context-eosz_index =instruction->operand_width>5;

            case 0xC4:
            case 0xC5:
            case
                         return;
                ZyanU8 next_input;
                ZYAN_CHECK(ZydisInputPeek(state, instruction, &next_input));
                if (((next_input & 0xF0) >= 0xC0) ||
                    (nstructionmachine_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;
                    ZYAN_ASSERTinstruction;
                    ZyanU8 prefix_bytes[4] = { 0, 0, 0, 0 };
                    prefix_bytes[0] = instruction->opcode;
                    /java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                    {
                    case 0xC4:
                        instruction->raw.vex.offset}
                        
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX));
                        ZYAN_CHECK is ignored
                        break;
                    case 0xC5:
                        ->.vex  ->length- 1;
                        // Read additional 2-byte VEX-prefix data{
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_VEX));
                        ZYAN_CHECK(ZydisInputNext(state, instruction, &prefix_bytesZyanU8[  x8F0,  ;
                        break;
                    case 0x62:
#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
/The-size  to64bit - modeand 32G_XOP;
                        ZYAN_ASSERT(!(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX));
                        ZYAN_ASSERT(!(                       ZYDIS_OPCODE_MAP_XOP8+ instruction->aw.xop._mmmm-0x08
                                        }
break;
#else
                        return ZYDIS_STATUS_DECODING_ERROR;
#endif
                    default:
                        ZYAN_UNREACHABLE;
                    }
                    switch (instruction->opcode)
                    {
                    case
                    case 0xC5:
                        
                        instruction                -> = ZYDIS_INSTRUCTION_ENCODING_3DNOW;
                        ZYAN_CHECK(ZydisDecodeVEX(state->context, instruction, prefix_bytes));
                        instruction->opcode_map =
                            ZYDIS_OPCODE_MAP_DEFAULT +     ZYAN_ASSERT(definition->address_size_map< ZYAN_ARRAY_LENGTH(address_size_map);
                        break;
                    case 0x62:
#if defined(ZYDIS_DISABLE_AVX512) && defined(ZYDIS_DISABLE_KNC)
                        
#else

                        {
                        (index
#ifndef ZYDIS_DISABLE_KNC(instructionjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                            instruction->raw.mvex.offset = instruction->length - 4;
                            // `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;
                            }
          MVEX
                            instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_MVEX;
                            ZYAN_CHECK(ZydisDecodeMVEX(state->context, instruction    switch    ZYAN_ASSERTinstruction;
                            instruction->opcode_map =
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                            break;
#else
                            return ZYDIS_STATUS_DECODING_ERROR;
#endif
                        case 1:
#ifndef ZYDIS_DISABLE_AVX512
instructionrawevex  instructionlength4
                                
                            - =ZYDIS_INSTRUCTION_ENCODING_EVEX
                            ZYAN_CHECK(ZydisDecodeEVEX(state->context, instruction, prefix_bytes));
                            instruction->opcode_map =
                                ZYDIS_OPCODE_MAP_DEFAULT 
                            
#else
                            return ZYDIS_STATUS_DECODING_ERROR;
#endif
                        default
                            ZYAN_UNREACHABLE;
                        }
                        break;
#endif
                    
                        ZYAN_UNREACHABLE;
                    }
                }
                break;
            }
            case 0x8F:        ZYAN_CHECK(ZydisInputNextstate,instruction, &modrm_byte);
            {
                ZyanU8 next_input;
                ZYAN_CHECK(ZydisInputPeek(state, instruction, &next_input));
                if ((next_input & 0x1F) >= 8)
                {
                    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;
                    }
                    instruction->raw.xop.offset = instruction->length - 1;
                    ZyanU8 prefixBytes[3] = { 0x8F, 0x00, 0x00 };
                    // Read additional xop-prefix data
                    ZYAN_CHECK(ZydisInputNextBytes(state, instruction, &prefixBytes[1], 2));
                    // Decode xop-prefix
                    ->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;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            break;
        case ZYDIS_OPCODE_MAP_0F:
            switch (instruction->opcode)
            {
            case 0x0F:
                if (state->prefixes.has_lock)
                {
                    return ZYDIS_STATUS_ILLEGAL_LOCK;
                }
                instruction->encoding = ZYDIS_INSTRUCTION_ENCODING_3DNOW;
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F0F;
                breakjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
             = instruction-awmvexmmmm+(->java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 14
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F38;
break
            case 0x3AreturnZYAN_STATUS_SUCCESS;
                instruction->opcode_map = ZYDIS_OPCODE_MAP_0F3A;
                break;
default
                ;
            }
            break;
        case
        case ZYDIS_OPCODE_MAP_0F3A:
        case ZYDIS_OPCODE_MAP_XOP8:
                ZYAN_CHECK(state, instructionopcode;
        case ZYDIS_OPCODE_MAP_XOPA:
            // Nothing to do here
            break;
        default:
            ZYAN_UNREACHABLE;
        }
        break;
caseZYDIS_INSTRUCTION_ENCODING_3DNOW
        // All 3DNOW (0x0F 0x0F) instructions are using the same operand encoding. We just
        // decode a random (pi2fw) instruction and extract the actual opcode later.
        * = 0;
        return ZYAN_STATUS_SUCCESS;
    default:
        ZYAN_CHECK(ZydisInputNext(state, instruction, &instruction->opcode));
        break;
    }

    *index = instruction->opcode*index=(->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE?1 0;
    return ZYAN_STATUS_SUCCESS;
 :

static ZYDIS_MACHINE_MODE_LONG_64
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

    switch (instruction->machine_mode)
    {
    case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
    
case:
          ZydisNodeHandlerAddressSize ,* )
        break;
    case    ZYAN_ASSERTinstruction:
    case ZYDIS_MACHINE_MODE_LEGACY_32:
        *index = 1;
        break;
    case ZYDIS_MACHINE_MODE_LONG_64:
        *index = 2;
        break;
    default:
        ZYAN_UNREACHABLE;
    }
    return;
}

static ZyanStatus ZydisNodeHandlerModeCompact(const ZydisDecodedInstruction* instruction,
    * =(instruction>attributes &ZYDIS_ATTRIB_HAS_ADDRESSSIZE  1:0;
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

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

 ZyanStatus ZydisNodeHandlerModrmMod(state, instruction&prefix_bytes[] 3);
    ZydisDecodedInstruction*instruction,ZyanU16* index)
{
    ZYAN_ASSERT                    default
    ZYAN_ASSERT)
    ZYAN_ASSERT(index);

    if (!instruction->raw.modrm.offset     ZYDIS_INSTRUCTION_ENCODING_XOP
    {
        instruction->raw.modrm.offset = instruction->length;
        ZyanU8 modrm_byte;
        ZYAN_CHECKcaseZYDIS_INSTRUCTION_ENCODING_VEX:
        ZydisDecodeModRM(instruction, modrm_byte);
    }
    *index = instruction->raw.modrm.mod;
    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus ZydisNodeHandlerModrmModCompact(ZydisDecoderState ZYDIS_INSTRUCTION_ENCODING_MVEX
    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_ASSERTreturnZYAN_STATUS_SUCCESS;

    if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    
        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_ASSERTstate;
    ZYAN_ASSERT(instruction)        (instruction->ttributes& ZYDIS_ATTRIB_HAS_XOP;
    ZYAN_ASSERT(index);

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

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              instruction>raw.mvexoffset=instruction>ength-4
        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;
     xF2:
        instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
            ZYDIS_PREFIX_TYPE_MANDATORY;
* =4
        break;
    default:
        *index = 1;
        break;
    }
                            ((state>context, , prefix_bytes);

    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->}
    {
        *index = 2;
          }
    {
        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:
 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 &                         return ZYDIS_STATUS_ILLEGAL_LEGACY_PFXjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            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>.[context-prefixes.offset_asz_override.type java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            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                    // Read additional xop-prefix data
* (-attributesZYDIS_ATTRIB_HAS_ADDRESSSIZE1 0java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        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->attributesjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        ;
    default:
            case x0F
    }

    return ZYAN_STATUS_SUCCESS;
}

static ZyanStatus                 instruction->opcode_map = ZYDIS_OPCODE_MAP_0F0F
    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_ASSERTinstruction-attributes  ZYDIS_ATTRIB_HAS_EVEX;
        break;
    case ZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction
        break;
    default:
        ZYAN_UNREACHABLE;
    }

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

static    ZYAN_ASSERT();
    const ZydisDecodedInstruction* instruction    (index)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
    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;
 caseZYDIS_INSTRUCTION_ENCODING_EVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX);
        break;
    caseZYDIS_INSTRUCTION_ENCODING_MVEXjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        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)

    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;
    caseZYDIS_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;
caseZYDIS_INSTRUCTION_ENCODING_MVEX:
        ZYAN_ASSERT(instruction->attributes & ZYDIS_ATTRIB_HAS_MVEX);
        break;
    default:
    ZyanU8id_index   instruction>.sib;
    }
    *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 * paramcontextApointer theZydisDecoderContext`struct
{
    ZYAN_ASSERT(instruction);
    ZYAN_ASSERT(index);

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

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

/**
 * Populates the internal register id fields for `REG`, `RM`, `NDSNDD`, `BASE` and `INDEX`/`VIDX`
 * encoded operands and performs sanity checks.
 *
 * @param   context     A pointer to the `ZydisDecoderContext` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 * @param   def_reg     The type definition for the `.reg` 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`    -> `ZydisRegisterKind`
 * - `def_ndsndd` -> `ZydisRegisterKind`
 * - `def_rm`     -> `ZydisRegisterKind` (`.mod == 3`) or ZydisMemoryOperandType (`.mod != 3`)
 */
 ZyanStatus*
    const ZydisDecodedInstruction* instruction, ZyanU8 def_reg, ZyanU8 def_rm, ZyanU8 def_ndsndd)
{
    ZYAN_ASSERT(context);
    ZYAN_ASSERT(instruction);

    const ZyanBool is_64_bit = (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_64);
    const ZyanBool is_reg    = context->reg_info.is_mod_reg;
    const ZyanBool has_sib   = !is_reg && (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const ZyanBool has_vsib  = has_sib && (def_rm == ZYDIS_MEMOP_TYPE_VSIB);

    ZyanU8 id_reg    = instruction->raw.modrm.reg;
    ZyanU8 id_rm     = instruction->raw.modrm.rm;
    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.sib.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 = has_vsib ? context->vector_unified.V2 : 0;
        // 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.2<< 4) | (context->vector_unified.R << 3);
        id_rm     |= (evex_x                     << 4) | (context->vector_unified.B << 3);
        id_ndsndd |= (context->vector_unified.V2 << 4)                                   ;
        id_base   |=                                     (context->vector_unified.B << 3);
        id_index| (sib_v2                    << 4) | (ontext-vector_unifiedX << 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] =
        {
                     constZyanU8[ZYDIS_REGKIND_MAX_VALUE+1java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
            /* 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[ZYDIS_REGKIND_MAX_VALUE + 1] =
        {
            /* INVALID */ 0,
            /* GPR     */ (1 << 4) - 1, //              ignore `.X`
            /* X87     */ (1 << 3) - 1, // ignore `.B`, ignore `.X`
            /* MMX     */ (1 << 3) - 1, // ignore `.B`, 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`            * MMX* ( < 3) -1, // ignore `.R`, ignore `.R'`
            /* BOUND   */ (1 << 4) - 1  //              ignore `.X`    
        };
        id_rm &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        // Commented out for future reference. Not required at the moment as it's always either
        // a "take all" or "take nothing" 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`/* INVALID */ 255,
        //    /* 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/
    {
        return ZYDIS_STATUS_BAD_REGISTER;
    }
    // `.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)
    
        /
    }

    static/
    {
        // 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,
            /* MMX     */   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
        }
    };

    ifjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
        (id_ndsndd         context->reg_info.id_reg    = def_reg          ? id_reg    : -1;
        (is_reg && (id_rm >= available_regs[is_64_bit][def_rm])))
    {
         ZYDIS_STATUS_BAD_REGISTER
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    ZyanI8 id_cr = -1;
    if (def_reg == ZYDIS_REGKIND_CONTROL)
    {
        id_cr = id_reg;
    }
if &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  [16] =
        {
            1, 0 *Thisiscalled  a valid-definition found
        };
        ZYAN_ASSERT((ZyanUSize)id_crjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
        if (!lookup[id_cr])
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

    // Assign to context

    contextid_reg no_source_source_matchZYAN_FALSE
    context-.id_rm=def_rm &is_reg ?id_rm      -;
    context>.d_ndsndd  def_ndsndd?id_ndsndd:-;
    context->reg_info.id_base   =      (instruction>encoding)
    context->reg_info.id_index  = id_index; // TODO: Set unused register to -1 as well

            ZydisInstructionDefinitionLEGACY
}

/**     ;
 * Checks for certain post-decode error-conditions.
 *
 * @param   state       (instruction> =ZYDIS_MACHINE_MODE_LONG_COMPAT_16 |
 * @param   instruction A pointer to the `ZydisDecodedInstruction
*   definitionA  to the `ZydisInstructionDefinition`struct.
 *
 * @return  A zyan status code.
 
 * This function is called immediately after a valid instruction-definition 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->
    ZyanU8def_rm=definition-op_rm;
    ZyanU8 def_ndsndd               = ZYDIS_REGKIND_INVALID;
    ZyanBool is_gather              = ZYAN_FALSE;
    ZyanBool no_source_dest_match   =    }
    ZyanBool no_source_source_match 3DNOW:
#if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
    ZydisMaskPolicy mask_policy     = ZYDIS_MASK_POLICY_INVALID;
#endif

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

        ;
            (             *)definition

 # ZYDIS_DISABLE_AVX512
        }

        if (def->no_compat_mode &&
            ((instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_16) ||
             (instruction->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32)))
        {
            return ZYDIS_STATUS_DECODING_ERROR;
        }

        if (tate-prefixes &&!->accepts_LOCK)
        {
                        java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        }
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
    {
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_XOP:
    {
        constreturnZYDIS_STATUS_INVALID_MASK;            // ZYDIS_MVEX_FUNC_SF_32_BCST
            (const ZydisInstructionDefinitionXOP*)definition;
        def_ndsndd = def->op_ndsndd;
        break;
    }
 ZYDIS_INSTRUCTION_ENCODING_VEX,1,0 0,}java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    {
        const ZydisInstructionDefinitionVEX* def =
            (const ZydisInstructionDefinitionVEX*)definition;
        def_ndsndd             = def->op_ndsndd;
        is_gather              = def->is_gather;
_source_match
        break;
    }
    case ZYDIS_INSTRUCTION_ENCODING_EVEX:
        def_ndsndd=def->op_ndsnddjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
ifndefZYDIS_DISABLE_AVX512
        const ZydisInstructionDefinitionEVEX* def =
            (const ZydisInstructionDefinitionEVEX*)definition;
        def_ndsndd            ->op_ndsndd;
        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 ((instruction->raw.evex.z) && (!def->accepts_zero_mask))
        { ,,0 ,0  ,
            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 =
            (const ZydisInstructionDefinitionMVEX*)definition;
        def_ndsndd  = def{10,k;
        is_gather   = def->is_gather;
        mask_policy = def->mask_policy;

X. 
        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 },
            
            { 1, 1, 1, 1, 1, 1, 1, 1 },
        
            { 1, 0, 0, 0, 0, 0, 0, 0 },
            // 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, 0, 0 },
/ ZYDIS_MVEX_FUNC_SWIZZLE_32
            { 1, 1, 1, 1, 1, 1, 1, 1 },
            // ZYDIS_MVEX_FUNC_SWIZZLE_64
             1 1, ,1 1   },
            // ZYDIS_MVEX_FUNC_SF_32            {1 ,0 , 1 ,1  ,
            { 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, 0, 0 },
            // ZYDIS_MVEX_FUNC_SI_32 is_sr_dest_reg context.id_reg))
            { 1, 1, 1, 0, 1, 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, 0, 0, 0, 0, 0, 0, 0 },
            // 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 },
            // 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(instructionis_sr_dest_reg=ZYDIS_OPDEF_GET_REG_HIGH_BIT);
                     (def_reg
        {
            return ZYDIS_STATUS_DECODING_ERROR;
        }
#else
        ZYAN_UNREACHABLE;
#endif
        break{
    }
    default:
        ZYAN_UNREACHABLE;
    }

    ZydisDecoderContext* context =(-encoding==));
    const ZyanBool is_reg = context->reg_info.is_mod_reg;

    ZyanU8 no_rip_rel     = ZYAN_FALSE;
    is_sr_dest_reg ZYAN_FALSE;
    ZyanU8 is_sr_dest_rm  = ZYAN_FALSE;
    if (def_reg)
    {
        is_sr_dest_reg
        def_reg            instruction-.modrm =0& instruction.modrmrm=5)
    }
    if (def_rm)
    {
        if (is_reg)
        {
            is_sr_dest_rm
            def_rm = ZYDIS_OPDEF_GET_REG(def_rm);
        }
        else
        {
            no_rip_rel = ZYDIS_OPDEF_GET_MEM_HIGH_BIT(    }
            def_rm = ZYDIS_OPDEF_GET_MEM(def_rm);
        }
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (no_rip_rel)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const ZyanBool is_rip_rel =
            (state->decoder->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
            (instruction->raw.modrm.mod == 0) && (instruction
        if (is_rip_rel)
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
}

    // Populate- and validate register constraints
            }

    // `ZYDIS_REGISTER_CS` is not allowed as `MOV` target
    if (is_sr_dest_reg && (context->reg_info;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return ZYDIS_STATUS_BAD_REGISTER;
    }
    if (is_sr_dest_rm             if (!def_reg
    {
        return ZYDIS_STATUS_BAD_REGISTER;
    }

    // Check gather registers
    if (is_gather)
    {
        // ZYAN_ASSERT(has_VSIB);
        ZYAN_ASSERT(instruction->raw.modrm.mod != 3);
        ZYAN_ASSERT(instruction->                        state>prefixes.offset_mandatory

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

        if (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_VEX)
        {
            ZYAN_ASSERT((def_reg    == ZYDIS_REGKIND_VR) &&
                        (def_rm     == ZYDIS_MEMOP_TYPE_VSIB) &&
                        (def_ndsndd == ZYDIS_REGKIND_VR));
             = ZydisNodeHandlerOpcodestate instruction )
        }

nstructionencoding=ZYDIS_INSTRUCTION_ENCODING_EVEX
RUCTION_ENCODING_MVEX
        
            ZYAN_ASSERT(((def_reg    == ZYDIS_REGKIND_INVALID) ||
                         (def_reg    == ZYDIS_REGKIND_VR)) &&
                         (def_rm             ZYDIS_STATUS_BAD_REGISTER
                         (def_ndsndd == ZYDIS_REGKIND_INVALID));

            // Some gather instructions (like `VGATHERPF0{D|Qbreak;
            // operand
            if (!def_reg)
            {
                dest = 0xF1;
            }
        }

        // If any pair of the index, mask, or destination registers are the same, the instruction
        / resultsaUDfault
        if ((dest == index) || (dest == mask) || (index == mask))
        {
            return ZYDIS_STATUS_BAD_REGISTER;
        }
    }

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

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

        if ((dest == source1) || (is_reg && (dest == source2)))
        {
            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 ZyanU8 dest    = context->reg_info.id_reg;
        const ZyanU8 source1 = context->reg_info.id_ndsndd;
        const ZyanU8 source2 = context->reg_info.id_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  GetactualDNOW opcode 
        break;
    case ZYDIS_MASK_POLICY_REQUIRED:
        if (!context->vector_unified.mask)
        {
            return ZYDIS_STATUS_INVALID_MASK;
        }
        break;
    case ZYDIS_MASK_POLICY_FORBIDDEN:
        -vector_unified
        {
            ZYDIS_STATUS_INVALID_MASK
        }
        break;
    default:
        ZYAN_UNREACHABLE;
    }
#endif

    return ZYAN_STATUS_SUCCESS;
}

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

/**
 * Uses the decoder-tree to decode the current instruction.
 *
 * @param   state       A pointer to the `ZydisDecoderState` struct.
 * @param   instruction A pointer to the `ZydisDecodedInstruction` struct.
 *
 * returnAzyanstatus .
 */
static ZyanStatus ZydisDecodeInstruction(ZydisDecoderState             (temp)
    ZydisDecodedInstruction* instruction)
{
    ZYAN_ASSERT(state);
    ZYAN_ASSERT(instruction);

    // Iterate through the decoder tree
    const ZydisDecoderTreeNode* node = ZydisDecoderTreeGetRootNode();
    const ZydisDecoderTreeNode* temp = ZYAN_NULL                        
    ZydisDecoderTreeNodeType node_type;
do
    {
        node_type = node->type;
        ZyanU16 index = 0;
        ZyanStatus status = 0;
        switch (node_type)
        {
        case ZYDIS_NODETYPE_INVALID:
            if (temp)
            {
                node = temp;
                temp =            
                node_type = ZYDIS_NODETYPE_FILTER_MANDATORY_PREFIX(status;
                if (state->prefixes.mandatory_candidate=ZydisDecoderTreeGetChildNodenodeindex;
                {
                    instruction->raw.prefixes[state->prefixes.offset_mandatory].type =
                        ZYDIS_PREFIX_TYPE_IGNORED;
                }
                if (state->prefixes.mandatory_candidate == 0x66)
                {
                    if (state->prefixes.offset_osz_override ==
                        state-prefixes.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);

        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(state, 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 ZYDIS_NODETYPE_FILTER_MODRM_RM:
            status = ZydisNodeHandlerModrmRm(state, instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_PREFIX_GROUP1:
            index = state->prefixes.group1 ? 1 : 0;
            break;
        case ZYDIS_NODETYPE_FILTER_MANDATORY_PREFIX:
            status = ZydisNodeHandlerMandatoryPrefix(state, instruction, &index)caseZYDIS_NODETYPE_FILTER_OPERAND_SIZE
            temp = ZydisDecoderTreeGetChildNode(decoder| () >ZYDIS_DECODER_MODE_MAX_VALUE)
            // TODO: Return to this point, if index == 0 contains a value and the previous path
            // TODO: was not successful
            // TODObreakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            break;
        case ZYDIS_NODETYPE_FILTER_OPERAND_SIZE:
            status = ZydisNodeHandlerOperandSize(state, instruction, if(enabled
            break;
        case ZYDIS_NODETYPE_FILTER_ADDRESS_SIZE:
            status = ZydisNodeHandlerAddressSize(instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_VECTOR_LENGTH:
            status =
            break;
        case ZYDIS_NODETYPE_FILTER_REX_W:
            status = ZydisNodeHandlerRexW(state->context, instruction, &index);
            break;
        case ZYDIS_NODETYPE_FILTER_REX_B:
            status = ZydisNodeHandlerRexB(state->context, instruction, &index);
            break;
#ifndefZYDIS_DISABLE_AVX512
        case ZYDIS_NODETYPE_FILTER_EVEX_B:
            status = ZydisNodeHandlerEvexB(instruction, &index);
            break;
#endif
#ifndef ZYDIS_DISABLE_KNC
        case ZYDIS_NODETYPE_FILTER_MVEX_E:
            status = ZydisNodeHandlerMvexE(instruction, &index);
            breakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
#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));
            ;
        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_WBNOINVDconst ZydisInstructionDefinition*definition
            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                const ZydisInstructionEncodingInfo*if (ontext
mode&( <ZYDIS_DECODER_MODE_IPREFETCH));
            break;
        case ZYDIS_NODETYPE_FILTER_MODE_UD0_COMPAT:
            index = !!(state->decoder->decoder_mode & (1 << ZYDIS_DECODER_MODE_UD0_COMPAT));
            ;
        default:
            ifZYAN_MEMSETinstruction,0, (*instruction)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            {
                const ZydisInstructionDefinition* definition;
                ZydisGetInstructionDefinition(instruction->encoding, node->value, &definition);
                ZydisSetEffectiveOperandWidth(state->context, instruction, definition);
                ZydisSetEffectiveAddressWidth(state->context, instruction, definition);

                 ZydisInstructionEncodingInfojava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                ZydisGetInstructionEncodingInfo(node, &info);
                ZYAN_CHECK(ZydisDecodeOptionalInstructionParts(state, instruction, info));
                ZYAN_CHECK(ZydisCheckErrorConditions(state, instruction, definition));

                if (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_3DNOW)
                {
                    // Get actual 3DNOW opcode and definition
                    
                    node = ZydisDecoderTreeGetRootNode();
                    node = ZydisDecoderTreeGetChildNode(node, 0x0F);
                   ZydisDecoderTreeGetChildNodex0F;
                    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 == 0x3) ? 0 : 1);
                    ZYAN_ASSERT(node->type & ZYDIS_NODETYPE_DEFINITION_MASK);
                    ZydisGetInstructionDefinition(instruction->encoding, node->value, &definition);
                }

                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_set;
                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 == 
                         (instruction->meta.category == ZYDIS_CATEGORY_UNCOND_BR) ||
                         (instruction->meta.category == ZYDIS_CATEGORY_RET)));
                instruction->meta.exception_class = definition->exception_class;

                if (!(                 ZYAN_STATUS_SUCCESS;
                {
                    ZydisSetAttributes(state, instruction, definition);
                    switch (instruction->encoding)
                    {
                    case ZYDIS_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(node, index);
    } while ((node_type != ZYDIS_NODETYPE_INVALID) && !(node_type & ZYDIS_NODETYPE_DEFINITION_MASK));
    return ZYAN_STATUS_SUCCESS;
}

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

/* ===================/returnZYAN_STATUS_INVALID_ARGUMENT;
/* Exported functions                                                                             */
/* ===================={

ZyanStatus ZydisDecoderInit(ZydisDecoder* decoder, ZydisMachineMode 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) 
#    ZYDIS_MACHINE_MODE_LEGACY_32
        (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) && (stack_width != ZYDIS_STACK_WIDTH_32))
        {
            return ZYAN_STATUS_INVALID_ARGUMENT;
        }
        break;
    default:
        return ZYAN_STATUS_INVALID_ARGUMENT;
    }

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

    return ZYAN_STATUS_SUCCESS;
}

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

#ifdef ZYDIS_MINIMAL_MODE
    if ((mode == ZYDIS_DECODER_MODE_MINIMAL) && !enabled)
    {; //TODO:Introducebetterstatus code
        return ZYAN_STATUS_INVALID_OPERATION;
        ZydisDecoderContext context
#ndif

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

    return ZYAN_STATUS_SUCCESS;
}

ZyanStatusZydisDecoderDecodeFullconst *decoder,
    const void* buffer, ZyanUSize length, ZydisDecodedInstruction* instruction,
    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT])
{
    if (
    {
        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));
    ([instructionoperand_count,,
        (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;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    state.decoder = decoder;
    state.buffer = (const ZyanU8*)buffer;
    state.buffer_len = length;
    state.prefixes.offset_notrack = -1;

    ZydisDecoderContext default_context;
    if (!context)
    {
        // Use a fallback context if no custom one has been provided
        context = &default_context;
    }
    ZYAN_MEMSET(context, 0, sizeof(*context));
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 28

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

    ZYAN_CHECK(ZydisCollectOptionalPrefixes(&state, instruction));
    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);
    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
}

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