freepascal.compiler/tests/utils/avx/asmtestgenerator.pas

{

  Copyright (C) <avx-testfile-generator> <Torsten Grundke>

  This source is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free
  Software Foundation; either version 2 of the License, or (at your option)
  any later version.

  This code is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.

  A copy of the GNU General Public License is available on the World Wide Web
  at <http://www.gnu.org/copyleft/gpl.html>. You can also obtain it by writing
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  MA 02110-1301, USA.
}

{$mode objfpc}

unit asmtestgenerator;

interface

uses BaseList, Classes;

type
  TOpType = (otUnknown, otTMMReg, otXMMReg, otXMMRM, otXMMRM16, otXMMRM8, otYMMReg, otYMMRM, otZMMReg, otZMMRM, otEAX, otRAX, otMem32,
             otMem8, otMem16, otMem64, otMem128, otMem256, otMem512, otREG64, otREG32, otREG16, otREG8, otRM16, otRM32, otRM64, otIMM8,
             otXMEM32, otXMEM64, otYMEM32, otYMEM64, otZMEM32, otZMEM64,
             otB16, otB32, otB64, otKREG);

  TOpMemType = Set of TOpType;

  TAsmCompareMode = (cmKORTESTNC, cmXORTestNZ);

  TOpMode = (omUnknown,
             omMX, omMY, omMZ,
             omXB32, omXB64, omYB32, omYB64, omZB32, omZB64,
             omXM, omYM, omZM,


             omKXM, omKYM, omKZM,
             omKXB32, omKXB64, omKYB32, omKYB64, omKZB32, omKZB64,
             omKXB32I, omKXB64I, omKXMI, omKYB32I, omKYB64I, omKYMI, omKZB32I, omKZB64I, omKZMI,

             omKMI, omKB32I, omKB64I,
             omMXI, omMYI, omMZI,
             omXXM, omXXB32, omXXB64, omXMI, omXB32I, omXB64I,
             omXXMI, omXXB32I, omXXB64I,

             omYYM, omYYB32, omYYB64, omYMI, omYB32I, omYB64I,
             omYYMI, omYYB32I, omYYB64I,
             omZZM, omZZB32, omZZB64, omZMI, omZB32I, omZB64I,
             omZZMI, omZZB32I, omZZB64I);

  TOperandListItem = class(TObject)
  private
    FOpActive: boolean;
    FOpNumber: integer;
    FOpTyp: TOpType;
    FValues: TStringList;
  public
    constructor Create;
    destructor Destroy; override;

    property OpNumber: integer read FOpNumber write FOpNumber;
    property OpTyp: TOpType read FOpTyp write FOpTyp;
    property OpActive: boolean read FOpActive write FOpActive;

    property Values: TStringList read FValues;
  end;

  TOperandList = class(TBaseList)
  private
    function GetItems(aIndex: integer): TOperandListItem;

  public
    function Add(aItem: TOperandListItem): integer;

    property Items[aIndex: integer]: TOperandListItem read GetItems;
  end;


  { TAsmTestGenerator }

  TAsmTestGenerator = class(TObject)
  private
    FReg8          : TStringList;
    FReg16         : TStringList;
    FReg32Base     : TStringList;
    FReg32Index    : TStringList;
    FReg64Base     : TStringList;
    FReg64Index    : TStringList;
    FReg6432Base   : TStringList;
    FReg6432Index  : TStringList;
    FReg32XMMIndex : TStringList;
    FReg32YMMIndex : TStringList;
    FReg32ZMMIndex : TStringList;
    FReg64XMMIndex : TStringList;
    FReg64YMMIndex : TStringList;
    FReg64ZMMIndex : TStringList;
    FRegKREG       : TStringList;

    Fx64: boolean;
    FAVX512: boolean;
    FSAE: boolean;
    FGas : boolean;

    procedure MemRegBaseIndexCombi(const aPrefix, aSuffix: String; aSLBaseReg, aSLIndexReg, aRList: TStringList);
    procedure MemRegBaseIndexCombiCDISP8N(const aPrefix, aSuffix: String; aSLBaseReg, aSLIndexReg, aRList: TStringList);
    procedure VectorMemRegBaseIndexCombi(const aPrefix, aSuffix: String; aSLBaseReg, aSLIndexReg, aRList: TStringList);
    function ParseBaseIndexReg(const aOp: string; var aBaseReg, aIndexReg: string): boolean;

    function InternalCalcTestData(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;
    function InternalCalcTestDataMREF(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;
    function InternalCalcTestDataCDISP8(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList;

    function ConvertToGasReg( aRegStr : string):string;
  public
    constructor Create(aGas:boolean);
    destructor Destroy; override;

    class procedure CalcTestData(aGas, aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
    class procedure CalcTestDataMREF(aGas, aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
    class procedure CalcTestDataCDisp8(aGas, aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);


    class procedure CalcTestInstFile;
    class procedure ListMemRefState;

    property x64: boolean read Fx64;
  end;

implementation

uses SysUtils, StrUtils, typinfo;


type
  TAsmOp={$i ../../../compiler/x86_64/x8664op.inc}
  TAttSuffix = (AttSufNONE,AttSufINT,AttSufFPU,AttSufFPUint,AttSufINTdual,AttSufMM,AttSufMMX,AttSufMMS);

  TMemRefSizeInfo = (msiUnknown, msiUnsupported, msiNoSize, msiNoMemRef,
                     msiMultiple, msiMultipleMinSize8, msiMultipleMinSize16, msiMultipleMinSize32,
                     msiMultipleMinSize64, msiMultipleMinSize128, msiMultipleminSize256, msiMultipleMinSize512,
                     msiMemRegSize, msiMemRegx16y32, msiMemRegx16y32z64, msiMemRegx32y64, msiMemRegx32y64z128, msiMemRegx64y128, msiMemRegx64y128z256,
                     msiMemRegx64y256, msiMemRegx64y256z512,
                     msiMem8, msiMem16, msiBMem16, msiMem32, msiBMem32, msiMem64, msiBMem64, msiMem128, msiMem256, msiMem512,
                     msiXMem32, msiXMem64, msiYMem32, msiYMem64, msiZMem32, msiZMem64,
                     msiVMemMultiple, msiVMemRegSize,
                     msiMemRegConst128,msiMemRegConst256,msiMemRegConst512);

  TMemRefSizeInfoBCST = (msbUnknown, msbBCST16, msbBCST32, msbBCST64, msbMultiple);
  TMemRefSizeInfoBCSTType = (btUnknown, bt1to2, bt1to4, bt1to8, bt1to16, bt1to32);

  TEVEXTupleState = (etsUnknown, etsIsTuple, etsNotTuple);
  TConstSizeInfo  = (csiUnknown, csiMultiple, csiNoSize, csiMem8, csiMem16, csiMem32, csiMem64);


  TInsTabMemRefSizeInfoRec = record
    MemRefSize               : TMemRefSizeInfo;
    MemRefSizeBCST           : TMemRefSizeInfoBCST;
    BCSTXMMMultiplicator     : byte;
    ExistsSSEAVX             : boolean;
    ConstSize                : TConstSizeInfo;
    BCSTTypes                : Set of TMemRefSizeInfoBCSTType;
    RegXMMSizeMask           : int64;
    RegYMMSizeMask           : int64;
    RegZMMSizeMask           : int64;
  end;


  TInsTabMemRefSizeInfoCache=array[TasmOp] of TInsTabMemRefSizeInfoRec;
  PInsTabMemRefSizeInfoCache=^TInsTabMemRefSizeInfoCache;

  TInsTabCache=array[TasmOp] of longint;
  PInsTabCache=^TInsTabCache;


const
  instabentries = {$i ../../../compiler/x86_64/x8664nop.inc}
  gas_needsuffix:array[tasmop] of TAttSuffix={$i ../../../compiler/x86_64/x8664ats.inc}

  MemRefMultiples: set of TMemRefSizeInfo = [msiMultiple, msiMultipleMinSize8,
                                             msiMultipleMinSize16, msiMultipleMinSize32,
                                             msiMultipleMinSize64, msiMultipleMinSize128,
                                             msiMultipleMinSize256, msiMultipleMinSize512,
                                             msiVMemMultiple];

  MemRefSizeInfoVMems: Set of TMemRefSizeInfo = [msiXMem32, msiXMem64, msiYMem32, msiYMem64,
                                                 msiZMem32, msiZMem64,
                                                 msiVMemMultiple, msiVMemRegSize];

  MEMTYPES: TOpMemType = [otXMMRM, otXMMRM16, otXMMRM8, otYMMRM, otZMMRM,
                          otMem8, otMem16, otMem32, otMem64, otMem128, otMem256, otMem512,
                          otRM16, otRM32, otRM64];
  BMEMTYPES: TOpMemType = [otB16, otB32, otB64];

var
  InsTabCache : PInsTabCache;
  InsTabMemRefSizeInfoCache: PInsTabMemRefSizeInfoCache;

type


    op2strtable=array[tasmop] of string[19];

    {Instruction flags }
    tinsflag = (
      { please keep these in order and in sync with IF_SMASK }
      IF_SM,                  { size match first two operands  }
      IF_SM2,
      IF_SB,                  { unsized operands can't be non-byte  }
      IF_SW,                  { unsized operands can't be non-word  }
      IF_SD,                  { unsized operands can't be nondword  }

      { unsized argument spec }
      { please keep these in order and in sync with IF_ARMASK }
      IF_AR0,                 { SB, SW, SD applies to argument 0  }
      IF_AR1,                 { SB, SW, SD applies to argument 1  }
      IF_AR2,                 { SB, SW, SD applies to argument 2  }

      IF_PRIV,                { it's a privileged instruction  }
      IF_SMM,                 { it's only valid in SMM  }
      IF_PROT,                { it's protected mode only  }
      IF_NOX86_64,            { removed instruction in x86_64  }
      IF_UNDOC,               { it's an undocumented instruction  }
      IF_FPU,                 { it's an FPU instruction  }
      IF_MMX,                 { it's an MMX instruction  }
      { it's a 3DNow! instruction  }
      IF_3DNOW,
      { it's a SSE (KNI, MMX2) instruction  }
      IF_SSE,
      { SSE2 instructions  }
      IF_SSE2,
      { SSE3 instructions  }
      IF_SSE3,
      { SSE64 instructions  }
      IF_SSE64,
      { SVM instructions  }
      IF_SVM,
      { SSE4 instructions  }
      IF_SSE4,
      IF_SSSE3,
      IF_SSE41,
      IF_SSE42,
      IF_MOVBE,
      IF_CLMUL,
      IF_AVX,
      IF_AVX2,
      IF_AVX512,
      IF_AVX102,      { AVX10.2 }
      IF_BMI1,
      IF_BMI2,
      { Intel ADX (Multi-Precision Add-Carry Instruction Extensions) }
      IF_ADX,
      IF_16BITONLY,
      IF_FMA,
      IF_FMA4,
      IF_TSX,
      IF_RAND,
      IF_XSAVE,
      IF_PREFETCHWT1,
      IF_SHA,
      IF_SHA512,
      IF_SM3NI,       { SM3  ShangMi 3 hash function }
      IF_SM4NI,       { SM4 }
      IF_GFNI,
      IF_AES,
      IF_AESKLE,
      IF_AESKLEWIDE,  { AESKLE WIDE_KL }
      IF_MOVRS,
      IF_MOVDIRI,
      IF_RAOINT,      { RAO-INT }
      IF_CMPCCXADD,
      IF_UINTR,
      IF_SERIALIZE,
      IF_USERMSR,     { USER_MSR }
      IF_AVXVNNI,     { AVX-VNNI }
      IF_AMX,         { AMX-BF16, AMX-TILE, AMX-INT8, AMX-FP16, AMX-FP8, AMX-TF32, AMX-COMPLEX, AMX-MOVRS, AMX-TRANSPOSE, AMX-AVX512 }
      IF_APX,         { APX_F }

      { mask for processor level }
      { please keep these in order and in sync with IF_PLEVEL }
      IF_8086,                { 8086 instruction  }
      IF_186,                 { 186+ instruction  }
      IF_286,                 { 286+ instruction  }
      IF_386,                 { 386+ instruction  }
      IF_486,                 { 486+ instruction  }
      IF_PENT,                { Pentium instruction  }
      IF_P6,                  { P6 instruction  }
      IF_KATMAI,              { Katmai instructions  }
      IF_WILLAMETTE,          { Willamette instructions }
      IF_PRESCOTT,            { Prescott instructions }
      IF_X86_64,
      IF_SANDYBRIDGE,         { Sandybridge-specific instruction }
      IF_NEC,                 { NEC V20/V30 instruction }

      { the following are not strictly part of the processor level, because
        they are never used standalone, but always in combination with a
        separate processor level flag. Therefore, they use bits outside of
        IF_PLEVEL, otherwise they would mess up the processor level they're
        used in combination with.
        The following combinations are currently used:
        [IF_AMD, IF_P6],
        [IF_CYRIX, IF_486],
        [IF_CYRIX, IF_PENT],
        [IF_CYRIX, IF_P6] }
      IF_CYRIX,               { Cyrix, Centaur or VIA-specific instruction }
      IF_AMD,                 { AMD-specific instruction  }

      { added flags }
      IF_PRE,                 { it's a prefix instruction }
      IF_PASS2,               { if the instruction can change in a second pass }
      IF_IMM4,                { immediate operand is a nibble (must be in range [0..15]) }
      IF_IMM3,                 { immediate operand is a triad (must be in range [0..7]) }

      IF_BCST2,
      IF_BCST4,
      IF_BCST8,
      IF_BCST16,
      IF_BCST32,
      IF_T2,                  { disp8 - tuple - 2 }
      IF_T4,                  { disp8 - tuple - 4 }
      IF_T8,                  { disp8 - tuple - 8 }
      IF_T1S,                 { disp8 - tuple - 1 scalar }
      IF_T1S8,
      IF_T1S16,
      IF_T1F32,
      IF_T1F64,
      IF_TMDDUP,
      IF_TFV,                 { disp8 - tuple - full vector }
      IF_TFVM,                { disp8 - tuple - full vector memory }
      IF_TQVM,
      IF_TMEM128,
      IF_THV,
      IF_THVM,
      IF_TOVM,
      IF_DISTINCT,            { destination and source registers must be distinct }
      IF_DALL                 { destination, index and mask registers should be distinct }

    );
    tinsflags=set of tinsflag;


      tinsentry=packed record
        opcode  : tasmop;
        ops     : byte;
        //optypes : array[0..max_operands-1] of longint;
        optypes : array[0..3] of int64; //TG
        code    : array[0..11] of char;
        flags   : tinsflags;
      end;
      pinsentry=^tinsentry;

const
      OT_NONE      = $00000000;

      { Bits 0..7: sizes }
      OT_BITS8     = $00000001;
      OT_BITS16    = $00000002;
      OT_BITS32    = $00000004;
      OT_BITS64    = $00000008;  { x86_64 and FPU }
      //OT_BITS128   = $10000000;  { 16 byte SSE }
      //OT_BITS256   = $20000000;  { 32 byte AVX }
      //OT_BITS512   = $40000000;  { 64 byte AVX512 }
      OT_BITS128   = $20000000;  { 16 byte SSE }
      OT_BITS256   = $40000000;  { 32 byte AVX }
      OT_BITS512   = $80000000;  { 64 byte AVX512 }

      OT_VECTORMASK = $1000000000;  { OPTIONAL VECTORMASK AVX512}
      OT_VECTORZERO = $2000000000;  { OPTIONAL ZERO-FLAG  AVX512}
      OT_VECTORBCST = $4000000000;  { BROADCAST-MEM-FLAG  AVX512}
      OT_VECTORSAE  = $8000000000;  { OPTIONAL SAE-FLAG  AVX512}
      OT_VECTORER   = $10000000000; { OPTIONAL ER-FLAG-FLAG  AVX512}
      OT_VECTORSIB  = $20000000000; { SIB-MEM-FLAG  AMX}

      OT_BITSB16    = OT_BITS16 or OT_VECTORBCST;
      OT_BITSB32    = OT_BITS32 or OT_VECTORBCST;
      OT_BITSB64    = OT_BITS64 or OT_VECTORBCST;


      OT_VECTOR_EXT_MASK = OT_VECTORMASK or OT_VECTORZERO or OT_VECTORBCST;

      OT_BITS80    = $00000010;  { FPU only  }
      OT_FAR       = $00000020;  { this means 16:16 or 16:32, like in CALL/JMP }
      OT_NEAR      = $00000040;
      OT_SHORT     = $00000080;

      { TODO: FAR/NEAR/SHORT are sizes too, they should be included into size mask,
        but this requires adjusting the opcode table }
      //OT_SIZE_MASK = $3000001F;  { all the size attributes  }
      OT_SIZE_MASK = $E000001F;  { all the size attributes  }
      OT_NON_SIZE  = int64(not int64(OT_SIZE_MASK));

      { Bits 8..11: modifiers }
      OT_SIGNED    = $00000100;  { the operand need to be signed -128-127 }
      OT_TO        = $00000200;  { reverse effect in FADD, FSUB &c  }
      OT_COLON     = $00000400;  { operand is followed by a colon  }
      OT_MODIFIER_MASK = $00000700;

      { Bits 12..15: type of operand }
      OT_REGISTER  = $00001000;
      OT_IMMEDIATE = $00002000;
      OT_MEMORY    = $0000C000;  { always includes 'OT_REGMEM' bit as well }
      OT_REGMEM    = $00008000;  { for r/m, ie EA, operands  }
      OT_TYPE_MASK = OT_REGISTER or OT_IMMEDIATE or OT_MEMORY or OT_REGMEM;

      OT_REGNORM   = OT_REGISTER or OT_REGMEM;  { 'normal' reg, qualifies as EA  }

      { Bits 20..22, 24..26: register classes
        otf_* consts are not used alone, only to build other constants. }
      otf_reg_cdt  = $00100000;
      otf_reg_gpr  = $00200000;
      otf_reg_sreg = $00400000;
      otf_reg_k    = $00800000;
      otf_reg_fpu  = $01000000;
      otf_reg_mmx  = $02000000;
      otf_reg_xmm  = $04000000;
      otf_reg_ymm  = $08000000;
      otf_reg_zmm  = $10000000;
      otf_reg_tmm  = $00000800;


      otf_reg_extra_mask = $1F000800;
      { Bits 16..19: subclasses, meaning depends on classes field }
      otf_sub0     = $00010000;
      otf_sub1     = $00020000;
      otf_sub2     = $00040000;
      otf_sub3     = $00080000;
      OT_REG_SMASK = otf_sub0 or otf_sub1 or otf_sub2 or otf_sub3;

      //OT_REG_EXTRA_MASK = $0F000000;
      OT_REG_EXTRA_MASK = $1F000800;

      OT_REG_TYPMASK = otf_reg_cdt or otf_reg_gpr or otf_reg_sreg or otf_reg_k or otf_reg_extra_mask;
      { register class 0: CRx, DRx and TRx }
      OT_REG_CDT   = OT_REGISTER or otf_reg_cdt or OT_BITS64;
      OT_REG_CREG  = OT_REG_CDT or otf_sub0;  { CRn  }
      OT_REG_DREG  = OT_REG_CDT or otf_sub1;  { DRn  }
      OT_REG_TREG  = OT_REG_CDT or otf_sub2;  { TRn  }
      OT_REG_CR4   = OT_REG_CDT or otf_sub3;  { CR4 (Pentium only)  }

      { register class 1: general-purpose registers }
      OT_REG_GPR   = OT_REGNORM or otf_reg_gpr;
      OT_RM_GPR    = OT_REGMEM or otf_reg_gpr;
      OT_REG8      = OT_REG_GPR or OT_BITS8;  { 8-bit GPR }
      OT_REG16     = OT_REG_GPR or OT_BITS16;
      OT_REG32     = OT_REG_GPR or OT_BITS32;
      OT_REG64     = OT_REG_GPR or OT_BITS64;

      { GPR subclass 0: accumulator: AL, AX, EAX or RAX }
      OT_REG_ACCUM = OT_REG_GPR or otf_sub0;
      OT_REG_AL    = OT_REG_ACCUM or OT_BITS8;
      OT_REG_AX    = OT_REG_ACCUM or OT_BITS16;
      OT_REG_EAX   = OT_REG_ACCUM or OT_BITS32;
      OT_REG_RAX   = OT_REG_ACCUM or OT_BITS64;
      { GPR subclass 1: counter: CL, CX, ECX or RCX }
      OT_REG_COUNT = OT_REG_GPR or otf_sub1;
      OT_REG_CL    = OT_REG_COUNT or OT_BITS8;
      OT_REG_CX    = OT_REG_COUNT or OT_BITS16;
      OT_REG_ECX   = OT_REG_COUNT or OT_BITS32;
      OT_REG_RCX   = OT_REG_COUNT or OT_BITS64;
      { GPR subclass 2: data register: DL, DX, EDX or RDX }
      OT_REG_DX    = OT_REG_GPR or otf_sub2 or OT_BITS16;
      OT_REG_EDX   = OT_REG_GPR or otf_sub2 or OT_BITS32;

      { register class 2: Segment registers }
      OT_REG_SREG  = OT_REGISTER or otf_reg_sreg or OT_BITS16;
      OT_REG_CS    = OT_REG_SREG or otf_sub0;  { CS  }
      OT_REG_DESS  = OT_REG_SREG or otf_sub1;  { DS, ES, SS (non-CS 86 registers)  }
      OT_REG_FSGS  = OT_REG_SREG or otf_sub2;  { FS, GS (386 extended registers)  }

      { register class 3: FPU registers }
      OT_FPUREG    = OT_REGISTER or otf_reg_fpu;
      OT_FPU0      = OT_FPUREG or otf_sub0;    { FPU stack register zero  }

      { register class 4: MMX (both reg and r/m) }
      OT_MMXREG    = OT_REGNORM or otf_reg_mmx;
      OT_MMXRM     = OT_REGMEM or otf_reg_mmx;

      { register class 5: XMM (both reg and r/m) }
      OT_XMMREG    = OT_REGNORM or otf_reg_xmm;
      OT_XMMRM     = OT_REGMEM or otf_reg_xmm;
      OT_XMEM32    = OT_REGNORM or otf_reg_xmm or otf_reg_gpr or OT_BITS32;
      OT_XMEM32_M  = OT_XMEM32 or OT_VECTORMASK;
      OT_XMEM64    = OT_REGNORM or otf_reg_xmm or otf_reg_gpr or OT_BITS64;
      OT_XMEM64_M  = OT_XMEM64 or OT_VECTORMASK;

      OT_XMMREG_M   = OT_XMMREG or OT_VECTORMASK;
      OT_XMMREG_MZ  = OT_XMMREG or OT_VECTORMASK or OT_VECTORZERO;
      OT_XMMRM_MZ   = OT_XMMRM  or OT_VECTORMASK or OT_VECTORZERO;
      OT_XMMREG_SAE = OT_XMMREG or OT_VECTORSAE;
      OT_XMMRM_SAE  = OT_XMMRM  or OT_VECTORSAE;
      OT_XMMREG_ER  = OT_XMMREG or OT_VECTORER;
      OT_XMMRM_ER   = OT_XMMRM  or OT_VECTORER;



      { register class 5: YMM (both reg and r/m) }
      OT_YMMREG     = OT_REGNORM or otf_reg_ymm;
      OT_YMMRM      = OT_REGMEM or otf_reg_ymm;
      OT_YMEM32     = OT_REGNORM or otf_reg_ymm or otf_reg_gpr or OT_BITS32;
      OT_YMEM32_M   = OT_YMEM32 or OT_VECTORMASK;
      OT_YMEM64     = OT_REGNORM or otf_reg_ymm or otf_reg_gpr or OT_BITS64;
      OT_YMEM64_M   = OT_YMEM64 or OT_VECTORMASK;

      OT_YMMREG_M   = OT_YMMREG or OT_VECTORMASK;
      OT_YMMREG_MZ  = OT_YMMREG or OT_VECTORMASK or OT_VECTORZERO;
      OT_YMMRM_MZ   = OT_YMMRM  or OT_VECTORMASK or OT_VECTORZERO;
      OT_YMMREG_SAE = OT_YMMREG or OT_VECTORSAE;
      OT_YMMRM_SAE  = OT_YMMRM  or OT_VECTORSAE;
      OT_YMMREG_ER  = OT_YMMREG or OT_VECTORER;
      OT_YMMRM_ER   = OT_YMMRM  or OT_VECTORER;


      { register class 5: ZMM (both reg and r/m) }
      OT_ZMMREG     = OT_REGNORM or otf_reg_zmm;
      OT_ZMMRM      = OT_REGMEM or otf_reg_zmm;
      OT_ZMEM32     = OT_REGNORM or otf_reg_zmm or otf_reg_gpr or OT_BITS32;
      OT_ZMEM32_M   = OT_ZMEM32 or OT_VECTORMASK;
      OT_ZMEM64     = OT_REGNORM or otf_reg_zmm or otf_reg_gpr or OT_BITS64;
      OT_ZMEM64_M   = OT_ZMEM64 or OT_VECTORMASK;

      OT_ZMMREG_M   = OT_ZMMREG or OT_VECTORMASK;
      OT_ZMMREG_MZ  = OT_ZMMREG or OT_VECTORMASK or OT_VECTORZERO;
      OT_ZMMRM_MZ   = OT_ZMMRM  or OT_VECTORMASK or OT_VECTORZERO;
      OT_ZMMREG_SAE = OT_ZMMREG or OT_VECTORSAE;
      OT_ZMMRM_SAE  = OT_ZMMRM  or OT_VECTORSAE;
      OT_ZMMREG_ER  = OT_ZMMREG or OT_VECTORER;
      OT_ZMMRM_ER   = OT_ZMMRM  or OT_VECTORER;


      OT_KREG       = OT_REGNORM or otf_reg_k;
      OT_KREG_M     = OT_KREG or OT_VECTORMASK;

      { register class 6: TMM (both reg and r/m) }
      OT_TMMREG     = OT_REGNORM or otf_reg_tmm;
      //OT_TMMRM      = OT_REGMEM or otf_reg_tmm;

      { Vector-Memory operands }
      OT_VMEM_ANY  = OT_XMEM32 or OT_XMEM64 or OT_YMEM32 or OT_YMEM64 or OT_ZMEM32 or OT_ZMEM64;

      { Memory operands }
      OT_MEM8      = OT_MEMORY or OT_BITS8;
      OT_MEM16     = OT_MEMORY or OT_BITS16;
      OT_MEM16_M   = OT_MEM16  or OT_VECTORMASK;
      OT_BMEM16    = OT_MEMORY or OT_BITS16 or OT_VECTORBCST;
      OT_MEM32     = OT_MEMORY or OT_BITS32;
      OT_MEM32_M   = OT_MEMORY or OT_BITS32 or OT_VECTORMASK;
      OT_BMEM32    = OT_MEMORY or OT_BITS32 or OT_VECTORBCST;
      OT_BMEM32_SAE= OT_MEMORY or OT_BITS32 or OT_VECTORBCST or OT_VECTORSAE;
      OT_MEM64     = OT_MEMORY or OT_BITS64;
      OT_MEM64_M   = OT_MEMORY or OT_BITS64 or OT_VECTORMASK;
      OT_BMEM64    = OT_MEMORY or OT_BITS64 or OT_VECTORBCST;
      OT_BMEM64_SAE= OT_MEMORY or OT_BITS64 or OT_VECTORBCST or OT_VECTORSAE;
      OT_MEM128    = OT_MEMORY or OT_BITS128;
      OT_MEM128_M  = OT_MEMORY or OT_BITS128 or OT_VECTORMASK;
      OT_MEM256    = OT_MEMORY or OT_BITS256;
      OT_MEM256_M  = OT_MEMORY or OT_BITS256 or OT_VECTORMASK;
      OT_MEM512    = OT_MEMORY or OT_BITS512;
      OT_MEM512_M  = OT_MEMORY or OT_BITS512 or OT_VECTORMASK;
      OT_MEM80     = OT_MEMORY or OT_BITS80;
      OT_SIBMEM    = OT_MEMORY or OT_VECTORSIB;



      OT_MEM_OFFS  = OT_MEMORY or otf_sub0;  { special type of EA  }
                                             { simple [address] offset  }

      { Matches any type of r/m operand }
      OT_MEMORY_ANY = OT_MEMORY or OT_RM_GPR or OT_XMMRM or OT_MMXRM or OT_YMMRM or OT_ZMMRM or OT_REG_EXTRA_MASK;

      { Immediate operands }
      OT_IMM8      = OT_IMMEDIATE or OT_BITS8;
      OT_IMM16     = OT_IMMEDIATE or OT_BITS16;
      OT_IMM32     = OT_IMMEDIATE or OT_BITS32;
      OT_IMM64     = OT_IMMEDIATE or OT_BITS64;

      OT_ONENESS   = otf_sub0;  { special type of immediate operand  }
      OT_UNITY     = OT_IMMEDIATE or OT_ONENESS;  { for shift/rotate instructions  }

      std_op2str:op2strtable={$i ../../../compiler/x86_64/x8664int.inc}

  InsTab:array[0..instabentries-1] of TInsEntry={$i ../../../compiler/x86_64/x8664tab.inc}

  function GroupOf4Reg( aReg:string):string;
  var len:dword;
      nr : dword;
      i : integer;
      st : string[3];
  begin
    len:=length(aReg);
    st:='';
    if (len=4) then
      st:=aReg[4];
    if (len=5) then
      st:=aReg[4]+aReg[5];
    if st<>'' then
    begin
      val(st,nr,i);
      nr:=nr and (not 3);
      str(nr,st);
      aReg:=aReg[1]+'MM'+st;
    end;
    GroupOf4Reg:=aReg;
  end;

  function EvenOddPairReg (aReg:string):string;
  begin
    if aReg[1]='K' then
    begin
      if aReg='K1' then aReg:='K0'
      else if aReg='K3' then aReg:='K2'
      else if aReg='K5' then aReg:='K4'
      else if aReg='K7' then aReg:='K6';
    end else
    if aReg[1]='T' then
      if aReg='TMM1' then aReg:='TMM0'
      else if aReg='TMM3' then aReg:='TMM2'
      else if aReg='TMM5' then aReg:='TMM4'
      else if aReg='TMM7' then aReg:='TMM6';
    EvenOddPairReg:=aReg;
  end;

  function MemPtr (var aRegs : string):string;
  var pt : string;
      ch : AnsiChar;
      po : sizeint;
  begin
    pt:='';
    po:=PosEx('word',aRegs,1);
    if po>0 then
    begin
      ch:=' ';
      if po>1 then
      begin
        ch:=aRegs[po-1];
        if ch in ['z','o','y','d','q'] then
        begin
          if ch = 'o' then ch:='x';
          pt:=ch;
          aRegs:=copy(aRegs,1,po-2)+copy(aRegs,po+4,length(aRegs));
        end;
      end;
    end;
    MemPtr:=pt;
  end;

  function ExtractReg(const aReg:string):string;  {get XMMxx, YMMxx, ZMMxx }
  var po,su : sizeint;
      ch,c2,c3 : AnsiChar;
      reg : string;
  begin
    reg:='';
    su:=1;
    po:=PosEx('MM',aReg,su);
    if (po >1) then
    begin
      ch:=aReg[po-1];
      c2:=' ';c3:=' ';
      if (ch in ['X','Y','Z','T']) and (length(aReg)>=po+2) then
      begin
        c2:=aReg[po+2];
        if c2 in ['0'..'9'] then
        begin
          reg:={ch+}'MM'+c2; {don't care about vector length just about it's number}
          if (length(aReg)>=po+3) then
          begin
            c2:=aReg[po+3];
            if c2 in ['0'..'9'] then
              reg:=reg+c2;
          end;
        end;
      end;
    end;
    ExtractReg:=reg;
  end;

  function notEqualRegs (const sl_Reg1,sl_Reg2,sl_Reg3:string):boolean;
  begin
    notEqualRegs:=true;
    if (sl_Reg1<>'') and (sl_Reg2<>'') and (sl_Reg1=sl_Reg2) then notEqualRegs:=false;
    if (sl_Reg1<>'') and (sl_Reg3<>'') and (sl_Reg1=sl_Reg3) then notEqualRegs:=false;
  end;

  function TAsmTestGenerator.ConvertToGasReg( aRegStr : string):string;
  var N : sizeint;
      ch,pr : AnsiChar;
      in_word  : boolean;
      newStr, newWord : string;
  begin
    ConvertToGasReg:=aRegStr;
    aRegStr:=AnsiUppercase(aRegStr);
    pr:=#0;
    in_word:=false;
    newStr:='';
    newWord:='';
    for n:=1 to length(aRegStr) do
    begin
      ch:=aRegStr[n];
      if ch in ['0'..'9','A'..'Z'] then
      begin
        in_word:=true;
        if newWord = '' then
        begin
          if ch in ['A','B','C','E','K'] then
          begin
            newStr:=newStr+'%';
          end;
          if ch in ['R'] then
          begin
            if pr<>'{' then
              newStr:=newStr+'%';
          end;
          if ch in ['D','X','Y','Z','T'] then
          begin
            if n<length(aRegStr) then
            begin
              if aRegStr[n+1] in ['M','L','X'] then
              begin
                newStr:=newStr+'%';
              end;
            end;
          end;
        end;
        newWord:=newWord+ch;
      end else
      begin
        if in_word then
        begin
          in_word:=false;
          newStr:=newStr+newWord;
          newWord:='';
          pr:=#0;
        end else
        begin
        end;
        newStr:=newStr+ch;
      end;
      pr:=ch;
    end;
    if in_word then newStr:=newStr+newWord;
    ConvertToGasReg:=AnsiLowercase(newStr);
  end;

  procedure BuildInsTabCache;
  var
    i : longint;
  begin
    new(instabcache);
    FillChar(instabcache^,sizeof(tinstabcache),$ff);
    i:=0;
    while (i<InsTabEntries) do
     begin
       if InsTabCache^[InsTab[i].OPcode]=-1 then
        InsTabCache^[InsTab[i].OPcode]:=i;
       inc(i);
     end;
  end;

  procedure BuildInsTabMemRefSizeInfoCache;
  var
    AsmOp: TasmOp;
    i,j: longint;
    insentry  : PInsEntry;

    MRefInfo: TMemRefSizeInfo;
    SConstInfo: TConstSizeInfo;
    actRegSize: int64;
    actMemSize: int64;
    actConstSize: int64;
    actRegCount: integer;
    actMemCount: integer;
    actConstCount: integer;
    actRegTypes  : int64;
    actRegMemTypes: int64;
    NewRegSize: int64;

    actVMemCount  : integer;
    actVMemTypes  : int64;

    RegMMXSizeMask: int64;
    RegXMMSizeMask: int64;
    RegYMMSizeMask: int64;
    RegZMMSizeMask: int64;

    RegMMXConstSizeMask: int64;
    RegXMMConstSizeMask: int64;
    RegYMMConstSizeMask: int64;
    RegZMMConstSizeMask: int64;

    RegBCSTSizeMask: int64;
    RegBCSTXMMSizeMask: int64;
    RegBCSTYMMSizeMask: int64;
    RegBCSTZMMSizeMask: int64;
    ExistsMemRef      : boolean;

    bitcount          : integer;
    ExistsCode336     : boolean;
    ExistsCode337     : boolean;
    ExistsSSEAVXReg   : boolean;

  begin
    new(InsTabMemRefSizeInfoCache);
    FillChar(InsTabMemRefSizeInfoCache^,sizeof(TInsTabMemRefSizeInfoCache),0);

    for AsmOp := low(TAsmOp) to high(TAsmOp) do
    begin
      i := InsTabCache^[AsmOp];

      if i >= 0 then
      begin


        InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize           := msiUnknown;
        InsTabMemRefSizeInfoCache^[AsmOp].MemRefSizeBCST       := msbUnknown;
        InsTabMemRefSizeInfoCache^[AsmOp].BCSTXMMMultiplicator := 0;
        InsTabMemRefSizeInfoCache^[AsmOp].ConstSize            := csiUnknown;
        InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX         := false;
        InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes            := [];

        insentry:=@instab[i];

        RegMMXSizeMask := 0;
        RegXMMSizeMask := 0;
        RegYMMSizeMask := 0;
        RegZMMSizeMask := 0;

        RegMMXConstSizeMask := 0;
        RegXMMConstSizeMask := 0;
        RegYMMConstSizeMask := 0;
        RegZMMConstSizeMask := 0;

        RegBCSTSizeMask:= 0;
        RegBCSTXMMSizeMask := 0;
        RegBCSTYMMSizeMask := 0;
        RegBCSTZMMSizeMask := 0;
        ExistsMemRef       := false;

        while (insentry^.opcode=AsmOp) do
        begin
          MRefInfo         := msiUnknown;

          actRegSize       := 0;
          actRegCount      := 0;
          actRegTypes      := 0;
          NewRegSize       := 0;

          actMemSize       := 0;
          actMemCount      := 0;
          actRegMemTypes   := 0;

          actVMemCount     := 0;
          actVMemTypes     := 0;

          actConstSize     := 0;
          actConstCount    := 0;

          ExistsCode336   := false; // indicate fixed operand size 32 bit
          ExistsCode337   := false; // indicate fixed operand size 64 bit
          ExistsSSEAVXReg := false;

          // parse insentry^.code for &336 and &337
          // &336 (octal) = 222 (decimal) == fixed operand size 32 bit
          // &337 (octal) = 223 (decimal) == fixed operand size 64 bit
          for i := low(insentry^.code) to high(insentry^.code) do
          begin
            case insentry^.code[i] of
              #222: ExistsCode336 := true;
              #223: ExistsCode337 := true;
              #0,#1,#2,#3: break;
            end;
          end;

          for i := 0 to insentry^.ops -1 do
          begin
            if (insentry^.optypes[i] and OT_REGISTER) = OT_REGISTER then
             case insentry^.optypes[i] and (OT_TMMREG or OT_XMMREG or OT_YMMREG or OT_ZMMREG or OT_KREG or OT_REG_EXTRA_MASK) of
                OT_TMMREG,
                OT_XMMREG,
                OT_YMMREG,
                OT_ZMMREG: ExistsSSEAVXReg := true;
                      else;
             end;
          end;


          for j := 0 to insentry^.ops -1 do
          begin
            if ((insentry^.optypes[j] and OT_XMEM32) = OT_XMEM32) OR
               ((insentry^.optypes[j] and OT_XMEM64) = OT_XMEM64) OR
               ((insentry^.optypes[j] and OT_YMEM32) = OT_YMEM32) OR
               ((insentry^.optypes[j] and OT_YMEM64) = OT_YMEM64) OR
               ((insentry^.optypes[j] and OT_ZMEM32) = OT_ZMEM32) OR
               ((insentry^.optypes[j] and OT_ZMEM64) = OT_ZMEM64) then
            begin
              inc(actVMemCount);

              case insentry^.optypes[j] and (OT_XMEM32 OR OT_XMEM64 OR OT_YMEM32 OR OT_YMEM64 OR OT_ZMEM32 OR OT_ZMEM64) of
                OT_XMEM32: actVMemTypes := actVMemTypes or OT_XMEM32;
                OT_XMEM64: actVMemTypes := actVMemTypes or OT_XMEM64;
                OT_YMEM32: actVMemTypes := actVMemTypes or OT_YMEM32;
                OT_YMEM64: actVMemTypes := actVMemTypes or OT_YMEM64;
                OT_ZMEM32: actVMemTypes := actVMemTypes or OT_ZMEM32;
                OT_ZMEM64: actVMemTypes := actVMemTypes or OT_ZMEM64;
                      else;
              end;
            end
            else if (insentry^.optypes[j] and OT_REGISTER) = OT_REGISTER then
            begin
              inc(actRegCount);

                NewRegSize := (insentry^.optypes[j] and OT_SIZE_MASK);
                if NewRegSize = 0 then
                  begin
                    case insentry^.optypes[j] and (OT_MMXREG or OT_XMMREG or OT_YMMREG or OT_ZMMREG or OT_KREG or OT_REG_EXTRA_MASK) of
                      OT_MMXREG: begin
                                   NewRegSize := OT_BITS64;
                                 end;
                      OT_XMMREG: begin
                                   NewRegSize := OT_BITS128;
                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
                                 end;
                      OT_YMMREG: begin
                                   NewRegSize := OT_BITS256;
                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
                                 end;
                      OT_ZMMREG: begin
                                   NewRegSize := OT_BITS512;
                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
                                 end;
                        OT_KREG: begin
                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
                                 end;

                            else NewRegSize := not(0);
                    end;
                end;

              actRegSize  := actRegSize or NewRegSize;
              actRegTypes := actRegTypes or (insentry^.optypes[j] and (OT_MMXREG or OT_XMMREG or OT_YMMREG or OT_ZMMREG or OT_KREG or OT_REG_EXTRA_MASK));
              end
            else if ((insentry^.optypes[j] and OT_MEMORY) <> 0) then
              begin
                inc(actMemCount);


                if ExistsSSEAVXReg and ExistsCode336 then
                  actMemSize := actMemSize or OT_BITS32
                else if ExistsSSEAVXReg and ExistsCode337 then
                  actMemSize := actMemSize or OT_BITS64
                else
                  actMemSize:=actMemSize or (insentry^.optypes[j] and (OT_SIZE_MASK OR OT_VECTORBCST));

                if (insentry^.optypes[j] and OT_REGMEM) = OT_REGMEM then
                  begin
                    actRegMemTypes  := actRegMemTypes or insentry^.optypes[j];
                  end;
              end
            else if ((insentry^.optypes[j] and OT_IMMEDIATE) = OT_IMMEDIATE) then
            begin
              inc(actConstCount);

              actConstSize    := actConstSize or (insentry^.optypes[j] and OT_SIZE_MASK);
            end
          end;

          if actConstCount > 0 then
          begin
            case actConstSize of
              0: SConstInfo := csiNoSize;
              OT_BITS8: SConstInfo := csiMem8;
              OT_BITS16: SConstInfo := csiMem16;
              OT_BITS32: SConstInfo := csiMem32;
              OT_BITS64: SConstInfo := csiMem64;
              else SConstInfo := csiMultiple;
            end;

            if InsTabMemRefSizeInfoCache^[AsmOp].ConstSize = csiUnknown then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := SConstInfo;
            end
            else if InsTabMemRefSizeInfoCache^[AsmOp].ConstSize <> SConstInfo then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := csiMultiple;
            end;
          end;

          if actVMemCount > 0 then
          begin
            if actVMemCount = 1 then
            begin
              if actVMemTypes > 0 then
              begin
                case actVMemTypes of
                  OT_XMEM32: MRefInfo := msiXMem32;
                  OT_XMEM64: MRefInfo := msiXMem64;
                  OT_YMEM32: MRefInfo := msiYMem32;
                  OT_YMEM64: MRefInfo := msiYMem64;
                  OT_ZMEM32: MRefInfo := msiZMem32;
                  OT_ZMEM64: MRefInfo := msiZMem64;
                        else;
                end;

                case actRegTypes of
                  OT_XMMREG: case MRefInfo of
                               msiXMem32,
                               msiXMem64: RegXMMSizeMask := RegXMMSizeMask or OT_BITS128;
                               msiYMem32,
                               msiYMem64: RegXMMSizeMask := RegXMMSizeMask or OT_BITS256;
                               msiZMem32,
                               msiZMem64: RegXMMSizeMask := RegXMMSizeMask or OT_BITS512;
                                     else;
                             end;
                  OT_YMMREG: case MRefInfo of
                               msiXMem32,
                               msiXMem64: RegYMMSizeMask := RegYMMSizeMask or OT_BITS128;
                               msiYMem32,
                               msiYMem64: RegYMMSizeMask := RegYMMSizeMask or OT_BITS256;
                               msiZMem32,
                               msiZMem64: RegYMMSizeMask := RegYMMSizeMask or OT_BITS512;
                                     else;
                             end;
                  OT_ZMMREG: case MRefInfo of
                               msiXMem32,
                               msiXMem64: RegZMMSizeMask := RegZMMSizeMask or OT_BITS128;
                               msiYMem32,
                               msiYMem64: RegZMMSizeMask := RegZMMSizeMask or OT_BITS256;
                               msiZMem32,
                               msiZMem64: RegZMMSizeMask := RegZMMSizeMask or OT_BITS512;
                                     else;
                             end;

                        //else InternalError(777209);
                end;


                if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiUnknown then
                begin
                  InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := MRefInfo;
                end
                else if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize <> MRefInfo then
                begin
                  if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize in [msiXMem32, msiXMem64, msiYMem32, msiYMem64, msiZMem32, msiZMem64] then
                  begin
                    InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiVMemMultiple;
                  end
                  else if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize <> msiVMemMultiple then;
                end;

              end;
            end
            else;
          end
          else
            begin
              if (actMemCount=2) and ((AsmOp=A_MOVS) or (AsmOp=A_CMPS)) then actMemCount:=1;

              ExistsMemRef := ExistsMemRef or (actMemCount > 0);

              case actMemCount of
                0: ; // nothing todo
                1: begin
                     MRefInfo := msiUnknown;

                     if not(ExistsCode336 or ExistsCode337) then
                       case actRegMemTypes and (OT_MMXRM or OT_XMMRM or OT_YMMRM or OT_ZMMRM or OT_REG_EXTRA_MASK) of
                         OT_MMXRM: actMemSize := actMemSize or OT_BITS64;
                         OT_XMMRM: actMemSize := actMemSize or OT_BITS128;
                         OT_YMMRM: actMemSize := actMemSize or OT_BITS256;
                         OT_ZMMRM: actMemSize := actMemSize or OT_BITS512;
                       end;

                     case actMemSize of
                                0: MRefInfo := msiNoSize;
                         OT_BITS8: MRefInfo := msiMem8;
                        OT_BITS16: MRefInfo := msiMem16;
                       OT_BITSB16: MRefInfo := msiBMem16;
                        OT_BITS32: MRefInfo := msiMem32;
                       OT_BITSB32: MRefInfo := msiBMem32;
                        OT_BITS64: MRefInfo := msiMem64;
                       OT_BITSB64: MRefInfo := msiBMem64;
                       OT_BITS128: MRefInfo := msiMem128;
                       OT_BITS256: MRefInfo := msiMem256;
                       OT_BITS512: MRefInfo := msiMem512;
                       OT_BITS80,
                       OT_FAR,
                       OT_NEAR,
                       OT_SHORT: ; // ignore
                       else
                         begin
                           bitcount := popcnt(qword(actMemSize));

                           if bitcount > 1 then MRefInfo := msiMultiple
                           else;
                         end;
                     end;

                     if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiUnknown then
                       begin
                         InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := MRefInfo;
                       end
                     else
                     begin
                       // ignore broadcast-memory
                       if not(MRefInfo in [msiBMem32, msiBMem64]) then
                       begin
                         if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize <> MRefInfo then
                         begin
                           with InsTabMemRefSizeInfoCache^[AsmOp] do
                           begin
                             if ((MemRefSize in [msiMem8, msiMULTIPLEMinSize8]) OR (MRefInfo = msiMem8))   then MemRefSize := msiMultipleMinSize8
                             else if ((MemRefSize in [ msiMem16,  msiMULTIPLEMinSize16])  OR (MRefInfo =  msiMem16)) then MemRefSize := msiMultipleMinSize16
                             else if ((MemRefSize in [ msiMem32,  msiMULTIPLEMinSize32])  OR (MRefInfo =  msiMem32)) then MemRefSize := msiMultipleMinSize32
                             else if ((MemRefSize in [ msiMem64,  msiMULTIPLEMinSize64])  OR (MRefInfo =  msiMem64)) then MemRefSize := msiMultipleMinSize64
                             else if ((MemRefSize in [msiMem128, msiMULTIPLEMinSize128])  OR (MRefInfo = msiMem128)) then MemRefSize := msiMultipleMinSize128
                             else if ((MemRefSize in [msiMem256, msiMULTIPLEMinSize256])  OR (MRefInfo = msiMem256)) then MemRefSize := msiMultipleMinSize256
                             else if ((MemRefSize in [msiMem512, msiMULTIPLEMinSize512])  OR (MRefInfo = msiMem512)) then MemRefSize := msiMultipleMinSize512
                             else MemRefSize := msiMultiple;
                           end;
                         end;
                       end;
                     end;

                     //if not(MRefInfo in [msiBMem32, msiBMem64]) and (actRegCount > 0) then
                     if actRegCount > 0 then
                     begin
                       if MRefInfo in [msiBMem16, msiBMem32, msiBMem64] then
                       begin
                         if IF_BCST2  in insentry^.flags then InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes := InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes + [bt1to2];
                         if IF_BCST4  in insentry^.flags then InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes := InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes + [bt1to4];
                         if IF_BCST8  in insentry^.flags then InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes := InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes + [bt1to8];
                         if IF_BCST16 in insentry^.flags then InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes := InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes + [bt1to16];
                         if IF_BCST32 in insentry^.flags then InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes := InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes + [bt1to32];

                         //InsTabMemRefSizeInfoCache^[AsmOp].BCSTTypes

                         // BROADCAST - OPERAND
                         RegBCSTSizeMask := RegBCSTSizeMask or actMemSize;

                         case actRegTypes and (OT_XMMREG or OT_YMMREG or OT_ZMMREG or OT_REG_EXTRA_MASK) of
                           OT_XMMREG: RegBCSTXMMSizeMask := RegBCSTXMMSizeMask or actMemSize;
                           OT_YMMREG: RegBCSTYMMSizeMask := RegBCSTYMMSizeMask or actMemSize;
                           OT_ZMMREG: RegBCSTZMMSizeMask := RegBCSTZMMSizeMask or actMemSize;
                                 else begin

                                        RegBCSTXMMSizeMask := not(0);
                                        RegBCSTYMMSizeMask := not(0);
                                        RegBCSTZMMSizeMask := not(0);
                                      end;
                         end;
                       end
                       else
                       case actRegTypes and (OT_MMXREG or OT_XMMREG or OT_YMMREG or OT_ZMMREG or OT_REG_EXTRA_MASK) of
                         OT_MMXREG: if actConstCount > 0 then RegMMXConstSizeMask := RegMMXConstSizeMask or actMemSize
                                     else RegMMXSizeMask := RegMMXSizeMask or actMemSize;
                         OT_XMMREG: if actConstCount > 0 then RegXMMConstSizeMask := RegXMMConstSizeMask or actMemSize
                                     else RegXMMSizeMask := RegXMMSizeMask or actMemSize;
                         OT_YMMREG: if actConstCount > 0 then RegYMMConstSizeMask := RegYMMConstSizeMask or actMemSize
                                     else RegYMMSizeMask := RegYMMSizeMask or actMemSize;
                         OT_ZMMREG: if actConstCount > 0 then RegZMMConstSizeMask := RegZMMConstSizeMask or actMemSize
                                     else RegZMMSizeMask := RegZMMSizeMask or actMemSize;
                               else begin
                                      RegMMXSizeMask := not(0);
                                      RegXMMSizeMask := not(0);
                                      RegYMMSizeMask := not(0);
                                      RegZMMSizeMask := not(0);

                                      RegMMXConstSizeMask := not(0);
                                      RegXMMConstSizeMask := not(0);
                                      RegYMMConstSizeMask := not(0);
                                      RegZMMConstSizeMask := not(0);
                                    end;
                       end;
                     end
                     else


                   end
                else;
              end;
            end;

          inc(insentry);
        end;

        if InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX then
        begin
          case RegBCSTSizeMask of
                    0: ; // ignore;
            OT_BITSB16: begin
                          InsTabMemRefSizeInfoCache^[AsmOp].MemRefSizeBCST       := msbBCST16;
                          InsTabMemRefSizeInfoCache^[AsmOp].BCSTXMMMultiplicator := 8;
                        end;
            OT_BITSB32: begin
                          InsTabMemRefSizeInfoCache^[AsmOp].MemRefSizeBCST       := msbBCST32;
                          InsTabMemRefSizeInfoCache^[AsmOp].BCSTXMMMultiplicator := 4;
                        end;
            OT_BITSB64: begin
                          InsTabMemRefSizeInfoCache^[AsmOp].MemRefSizeBCST       := msbBCST64;
                          InsTabMemRefSizeInfoCache^[AsmOp].BCSTXMMMultiplicator := 2;
                        end;
                  else begin
                         InsTabMemRefSizeInfoCache^[AsmOp].MemRefSizeBCST := msbMultiple;
                       end;
          end;
        end;


        if (InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize in MemRefMultiples) and
           (InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX)then
        begin
          if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiVMemMultiple then
          begin
            if ((RegXMMSizeMask = OT_BITS128) or (RegXMMSizeMask = 0))     and
               ((RegYMMSizeMask = OT_BITS256) or (RegYMMSizeMask = 0))     and
               ((RegZMMSizeMask = OT_BITS512) or (RegZMMSizeMask = 0))     and
               ((RegXMMSizeMask or RegYMMSizeMask or RegZMMSizeMask) <> 0) then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiVMemRegSize;
            end;
          end
          else if (RegMMXSizeMask or RegMMXConstSizeMask) <> 0 then
          begin
            if ((RegMMXSizeMask or RegMMXConstSizeMask) = OT_BITS64)  and
               ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS128) and
               ((RegYMMSizeMask or RegYMMConstSizeMask) = 0)          and
               ((RegZMMSizeMask or RegZMMConstSizeMask) = 0) then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegSize;
            end;
          end
          else if (((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS128) or ((RegXMMSizeMask or RegXMMConstSizeMask) = 0)) and
                  (((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS256) or ((RegYMMSizeMask or RegYMMConstSizeMask) = 0)) and
                  (((RegZMMSizeMask or RegZMMConstSizeMask) = OT_BITS512) or ((RegZMMSizeMask or RegZMMConstSizeMask) = 0)) and
                  (((RegXMMSizeMask or RegXMMConstSizeMask or
                     RegYMMSizeMask or RegYMMConstSizeMask or
                     RegZMMSizeMask or RegZMMConstSizeMask)) <> 0) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegSize;
          end
          else if (RegXMMSizeMask or RegXMMConstSizeMask = OT_BITS16) and
                  (RegYMMSizeMask or RegYMMConstSizeMask = OT_BITS32) and
                  (RegZMMSizeMask or RegZMMConstSizeMask = 0) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx16y32;
          end
          else if (RegXMMSizeMask or RegXMMConstSizeMask = OT_BITS16) and
                  (RegYMMSizeMask or RegYMMConstSizeMask = OT_BITS32) and
                  (RegZMMSizeMask or RegZMMConstSizeMask = OT_BITS64) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx16y32z64;
          end
          else if ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS32) and
                  ((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS64) then
          begin
            if ((RegZMMSizeMask or RegZMMConstSizeMask) = 0) then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx32y64;
            end
            else if ((RegZMMSizeMask or RegZMMConstSizeMask) = OT_BITS128) then
            begin
              InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx32y64z128;
            end;
          end
          else if ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS64)  and
                  ((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS128) and
                  ((RegZMMSizeMask or RegZMMConstSizeMask) = 0) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y128;
          end
          else if ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS64)  and
                  ((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS128) and
                  ((RegZMMSizeMask or RegZMMConstSizeMask) = OT_BITS256) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y128z256;
          end
          else if ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS64)  and
                  ((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS256) and
                  ((RegZMMSizeMask or RegZMMConstSizeMask) = 0) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y256;
          end
          else if ((RegXMMSizeMask or RegXMMConstSizeMask) = OT_BITS64)  and
                  ((RegYMMSizeMask or RegYMMConstSizeMask) = OT_BITS256) and
                  ((RegZMMSizeMask or RegZMMConstSizeMask) = OT_BITS512) then
          begin
            InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y256z512;
          end
          else if ((RegXMMConstSizeMask = 0) or (RegXMMConstSizeMask = OT_BITS128))     and
                  ((RegYMMConstSizeMask = 0) or (RegYMMConstSizeMask = OT_BITS256))     and
                  ((RegZMMConstSizeMask = 0) or (RegZMMConstSizeMask = OT_BITS512))     and
                  ((RegXMMConstSizeMask or RegYMMConstSizeMask or RegZMMConstSizeMask) <> 0) and
                  (
                   ((RegXMMSizeMask or RegYMMSizeMask or RegZMMSizeMask) = OT_BITS128) or
                   ((RegXMMSizeMask or RegYMMSizeMask or RegZMMSizeMask) = OT_BITS256) or
                   ((RegXMMSizeMask or RegYMMSizeMask or RegZMMSizeMask) = OT_BITS512)
                  ) then
          begin
            case RegXMMSizeMask or RegYMMSizeMask or RegZMMSizeMask of
              OT_BITS128: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegConst128;
              OT_BITS256: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegConst256;
              OT_BITS512: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegConst512;
                     else InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMultiple;
            end;
          end
          else
          begin
            if not(
                   (AsmOp = A_CVTSI2SS) or
                   (AsmOp = A_CVTSI2SD) or
                   (AsmOp = A_CVTPD2DQ) or
                   (AsmOp = A_VCVTPD2DQ) or
                   (AsmOp = A_VCVTPD2PS) or
                   (AsmOp = A_VCVTSI2SD) or
                   (AsmOp = A_VCVTSI2SS) or
                   (AsmOp = A_VCVTTPD2DQ) or
                   (AsmOp = A_VCVTPD2UDQ) or
                   (AsmOp = A_VCVTQQ2PS) or
                   (AsmOp = A_VCVTTPD2UDQ) or
                   (AsmOp = A_VCVTUQQ2PS) or
                   (AsmOp = A_VCVTUSI2SD) or
                   (AsmOp = A_VCVTUSI2SS) or


                   // TODO check
                   (AsmOp = A_VCMPSS)


                  ) then;

          end;

        end
        else if (InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX) and
                (InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiUnknown) and
                (not(ExistsMemRef)) then
        begin
          InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiNoMemRef;
        end;

        InsTabMemRefSizeInfoCache^[AsmOp].RegXMMSizeMask:=RegXMMSizeMask;
        InsTabMemRefSizeInfoCache^[AsmOp].RegYMMSizeMask:=RegYMMSizeMask;
        InsTabMemRefSizeInfoCache^[AsmOp].RegZMMSizeMask:=RegZMMSizeMask;

      end;
    end;

    for AsmOp := low(TAsmOp) to high(TAsmOp) do
    begin


      // only supported intructiones with SSE- or AVX-operands
      if not(InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX) then
      begin
        InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize  := msiUnknown;
        InsTabMemRefSizeInfoCache^[AsmOp].ConstSize   := csiUnknown;
      end;
    end;
  end;

{ TOperandListItem }

constructor TOperandListItem.Create;
begin
  inherited;

  FOpActive := false;
  FOpNumber := -1;
  FOpTyp    := otUnknown;
  FValues := TStringList.Create;
end;

destructor TOperandListItem.Destroy;
begin
  FreeAndNil(FValues);
  inherited;
end;

{ TOperandList }

function TOperandList.Add(aItem: TOperandListItem): integer;
begin
  result := FList.Add(aItem);
end;

function TOperandList.GetItems(aIndex: integer): TOperandListItem;
begin
  result := TOperandListItem(FList[aIndex]);
end;

{ TAsmTestGenerator }

function TAsmTestGenerator.InternalCalcTestData(const aInst, aOp1, aOp2, aOp3,
  aOp4: String): TStringList;
var
  i: integer;
  Item: TOperandListItem;
  OItem1: TOperandListItem;
  OItem2: TOperandListItem;
  OItem3: TOperandListItem;
  OItem4: TOperandListItem;

  il_Op: integer;
  il_Op1: integer;
  il_Op2: integer;
  il_Op3: integer;
  il_Op4: integer;

  sSuffix: string;
  sPrefix: string;
  sl_Operand: String;
  sl_Inst   : String;
  sl_RegCombi: String;
  sl_Prefix: String;
  UsePrefix: boolean;
  il_Operands: integer;
  UsedParams: cardinal;
  UseDefault: boolean;
  sl_RegCombi1: string;
  sl_RegCombi2: string;
  sl_RegCombi3: string;
  sl_Reg1 : string;
  sl_Reg2 : string;
  sl_Reg3 : string;
  sPtr : string;
  Distinct : boolean;
  DistinctAll : boolean;
  MaskRegNeeded:boolean;
  noZSuffix : boolean;
  EvenPair: boolean;
  GroupOf4: boolean;

  function PrepareOperandTyp(const aTyp: String): String;
  begin
    result := aTyp;
    if copy(result, length(result), 1) = '*' then result := copy(result, 1, length(result) - 1);
    if result = 'XMMRM128' then result := 'XMMRM';
    if result = 'YMMRM256' then result := 'YMMRM';
  end;


begin
  result := TStringList.Create;

  OItem1 := TOperandListItem.Create;
  try
    OItem2 := TOperandListItem.Create;
    try
      OItem3 := TOperandListItem.Create;
      try
        OItem4 := TOperandListItem.Create;
        try

          UsePrefix := (UpperCase(aInst) = 'VCVTPD2DQ') OR
                       (UpperCase(aInst) = 'VCVTPD2PS') OR
                       (UpperCase(aInst) = 'VCVTSI2SD') OR
                       (UpperCase(aInst) = 'VCVTSI2SS') OR
                       (UpperCase(aInst) = 'VCVTTPD2DQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTUQQ2PS') or
                       (UpperCase(aInst) = 'VCVTQQ2PS') or
                       (UpperCase(aInst) = 'VCVTUSI2SD') or
                       (UpperCase(aInst) = 'VCVTUSI2SS') or
                       (UpperCase(aInst) = 'VFPCLASSPD') or
                       (UpperCase(aInst) = 'VFPCLASSPS') or

                       (UpperCase(aInst) = 'VFPCLASSPH') or
                       (UpperCase(aInst) = 'VCVTUQQ2PH') or
                       (UpperCase(aInst) = 'VCVTQQ2PH') or
                       (UpperCase(aInst) = 'VCVTPD2PH') or

                       (UpperCase(aInst) = 'VCVTPS2PHX') or // no Z
                       (UpperCase(aInst) = 'VCVTDQ2PH') or  // no Z
                       (UpperCase(aInst) = 'VCVTUDQ2PH') or // no Z

                       (UpperCase(aInst) = 'VCVTNEPS2BF16') or
                       (UpperCase(aInst) = 'VLDMXCSR') or
                       (UpperCase(aInst) = 'VSTMXCSR') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQS') or
                       (UpperCase(aInst) = 'VFPCLASSBF16') or
                       (UpperCase(aInst) = 'VCVTTPD2DQS') or
                       (UpperCase(aInst) = 'VCVTPH2HF8') or
                       (UpperCase(aInst) = 'VCVTPH2BF8S') or
                       (UpperCase(aInst) = 'VCVTPH2HF8S') or
                       (UpperCase(aInst) = 'VCVTPH2BF8') or
                       (UpperCase(aInst) = '') or
                       (UpperCase(aInst) = '') or
                       (UpperCase(aInst) = '')

                       //(UpperCase(aInst) = 'VPMOVZXWQ') or
                       //(UpperCase(aInst) = 'VCMPSS')

                       ;


          noZSuffix := (UpperCase(aInst) = 'VCVTPD2DQ') or
                       (UpperCase(aInst) = 'VCVTPD2PS') or
                       (UpperCase(aInst) = 'VCVTTPD2DQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTQQ2PS') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTUQQ2PS') or
                       (UpperCase(aInst) = 'VCVTSI2SD') OR
                       (UpperCase(aInst) = 'VCVTSI2SS') OR
                       (UpperCase(aInst) = 'VCVTUSI2SD') or
                       (UpperCase(aInst) = 'VCVTUSI2SS') or

                       (UpperCase(aInst) = 'VCVTPS2PHX') or // no Z
                       (UpperCase(aInst) = 'VCVTDQ2PH') or  // no Z
                       (UpperCase(aInst) = 'VCVTUDQ2PH') or // no Z
                       (UpperCase(aInst) = 'VCVTNEPS2BF16') or
                       (UpperCase(aInst) = 'VLDMXCSR') or
                       (UpperCase(aInst) = 'VSTMXCSR') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQS') or
                       (UpperCase(aInst) = 'VCVTTPD2DQS') or
                       (UpperCase(aInst) = 'VCVTPH2HF8') or
                       (UpperCase(aInst) = 'VCVTPH2BF8S') or
                       (UpperCase(aInst) = 'VCVTPH2HF8S') or
                       (UpperCase(aInst) = 'VCVTPH2BF8') or
                       (UpperCase(aInst) = '') or
                       (UpperCase(aInst) = '') or
                       (UpperCase(aInst) = '') or
                       (UpperCase(aInst) = '')
                       ;


          Distinct := (UpperCase(aInst) = 'VFCMADDCPH') OR
                       (UpperCase(aInst) = 'VFCMADDCSH') OR
                       (UpperCase(aInst) = 'VFMADDCPH') OR
                       (UpperCase(aInst) = 'VFMADDCSH') OR
                       (UpperCase(aInst) = 'VFCMULCPH') OR
                       (UpperCase(aInst) = 'VFCMULCSH') OR
                       (UpperCase(aInst) = 'VFMULCPH') OR
                       (UpperCase(aInst) = 'VFMULCSH') OR
                       (UpperCase(aInst) = 'TCONJTCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TTCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TTCMMRLFP16PS') OR
                       (UpperCase(aInst) = 'TTDPBF16PS') OR
                       (UpperCase(aInst) = 'TTDPFP16PS') OR
                       (UpperCase(aInst) = 'TTMMULTF32PS') OR
                       (UpperCase(aInst) = 'TMMULTF32PS') OR
                       (UpperCase(aInst) = 'TDPHF8PS') OR
                       (UpperCase(aInst) = 'TDPHBF8PS') OR
                       (UpperCase(aInst) = 'TDPBHF8PS') OR
                       (UpperCase(aInst) = 'TDPBF8PS') OR
                       (UpperCase(aInst) = 'TCMMRLFP16PS') OR
                       (UpperCase(aInst) = 'TCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TDPFP16PS') OR
                       (UpperCase(aInst) = 'TDPBUUD') OR
                       (UpperCase(aInst) = 'TDPBUSD') OR
                       (UpperCase(aInst) = 'TDPBSUD') OR
                       (UpperCase(aInst) = 'TDPBSSD') OR
                       (UpperCase(aInst) = 'TDPBF16PS') OR
                       (UpperCase(aInst) = '') OR
                       (UpperCase(aInst) = '') OR
                       (UpperCase(aInst) = '')
                       ;

          DistinctAll := (UpperCase(aInst) = 'TCONJTCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TTCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TTCMMRLFP16PS') OR
                       (UpperCase(aInst) = 'TTDPBF16PS') OR
                       (UpperCase(aInst) = 'TTDPFP16PS') OR
                       (UpperCase(aInst) = 'TTMMULTF32PS') OR
                       (UpperCase(aInst) = 'TMMULTF32PS') OR
                       (UpperCase(aInst) = 'TDPHF8PS') OR
                       (UpperCase(aInst) = 'TDPHBF8PS') OR
                       (UpperCase(aInst) = 'TDPBHF8PS') OR
                       (UpperCase(aInst) = 'TDPBF8PS') OR
                       (UpperCase(aInst) = 'TCMMRLFP16PS') OR
                       (UpperCase(aInst) = 'TCMMIMFP16PS') OR
                       (UpperCase(aInst) = 'TDPFP16PS') OR
                       (UpperCase(aInst) = 'TDPBUUD') OR
                       (UpperCase(aInst) = 'TDPBUSD') OR
                       (UpperCase(aInst) = 'TDPBSUD') OR
                       (UpperCase(aInst) = 'TDPBSSD') OR
                       (UpperCase(aInst) = 'TDPBF16PS') OR
                       (UpperCase(aInst) = '') OR
                       (UpperCase(aInst) = '')
                       ;

          EvenPair:= (UpperCase(aInst) = 'VP2INTERSECTD') OR { kreg even-odd pair}
                      (UpperCase(aInst) = 'VP2INTERSECTQ') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ1RST1') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ1RS') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ0RST1') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ0RS') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ1T1') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ1') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ0T1') OR
                      (UpperCase(aInst) = 'T2RPNTLVWZ0') OR
                      (UpperCase(aInst) = '') OR
                      (UpperCase(aInst) = '') OR
                      (UpperCase(aInst) = '') OR
                      (UpperCase(aInst) = '') OR
                      (UpperCase(aInst) = '') OR
                      (UpperCase(aInst) = '')
                      ;
          GroupOf4:= (UpperCase(aInst) = 'V4FMADDPS') OR   { src reg group of 4 registers }
                     (UpperCase(aInst) = 'V4FMADDSS') OR
                     (UpperCase(aInst) = 'V4FNMADDPS') OR
                     (UpperCase(aInst) = 'V4FNMADDSS') OR
                     (UpperCase(aInst) = 'VP4DPWSSD') OR
                     (UpperCase(aInst) = 'VP4DPWSSDS')
                     ;

          MaskRegNeeded := (Pos('VGATHER', Uppercase(aInst)) = 1) or
                           (Pos('VPGATHER', Uppercase(aInst)) = 1) or
			   (Pos('VPSCATTER', Uppercase(aInst)) = 1) or
			   (Pos('VSCATTER', Uppercase(aInst)) = 1);

          DistinctAll:=DistinctAll or MaskRegNeeded;
          Distinct:=Distinct or MaskRegNeeded;

          for il_Op := 1 to 4 do
          begin
            sl_Prefix := '';

            case il_Op of
              1: begin
                   Item := OItem1;
                   sl_Operand := aOp1;
                 end;
              2: begin
                   Item := OItem2;
                   sl_Operand := aOp2;
                 end;
              3: begin
                   Item := OItem3;
                   sl_Operand := aOp3;
                 end;
              4: begin
                   Item := OItem4;
                   sl_Operand := aOp4;
                 end;
            end;

            sl_Operand := PrepareOperandTyp(sl_Operand);

            if (AnsiSameText(sl_Operand, 'TMMREG')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMReg; { pretend as XMMREG }
              Item.OpActive := true;

              sSuffix := '';
              sPrefix := '';

              Item.Values.Add(sPrefix + 'TMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'TMM7' + sSuffix);

            end
            else if (AnsiSameText(sl_Operand, 'XMMREG')) or
               (AnsiSameText(sl_Operand, 'XMMREG_M')) or
               (AnsiSameText(sl_Operand, 'XMMREG_MZ')) or
               (AnsiSameText(sl_Operand, 'XMMREG_ER')) or
               (AnsiSameText(sl_Operand, 'XMMREG_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMReg;
              Item.OpActive := true;

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{ru-sae},' else sSuffix := ', {ru-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM9' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM18' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM27' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM31' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('XMM0');
                    Item.Values.Add('XMM9');
                    Item.Values.Add('XMM18');
                    Item.Values.Add('XMM27');
                    Item.Values.Add('XMM31');
                  end;
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM8' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM12' + sSuffix);
                  Item.Values.Add(sPrefix + 'XMM15' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('XMM0');
                    Item.Values.Add('XMM4');
                    Item.Values.Add('XMM8');
                    Item.Values.Add('XMM12');
                    Item.Values.Add('XMM15');
                  end;
                end;
              end;
              sPrefix := '';
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{ru-sae},' else sSuffix := ', {ru-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM9' + sSuffix);
                  Item.Values.Add('XMM9');
                  Item.Values.Add(sPrefix + 'XMM18' + sSuffix);
                  Item.Values.Add('XMM18');
                  Item.Values.Add(sPrefix + 'XMM27' + sSuffix);
                  Item.Values.Add('XMM27');
                  Item.Values.Add(sPrefix + 'XMM31' + sSuffix);
                  Item.Values.Add('XMM31');
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
                  Item.Values.Add('XMM4');
                  Item.Values.Add(sPrefix + 'XMM8' + sSuffix);
                  Item.Values.Add('XMM8');
                  Item.Values.Add(sPrefix + 'XMM12' + sSuffix);
                  Item.Values.Add('XMM15');
                  Item.Values.Add(sPrefix + 'XMM15' + sSuffix);
                end;
                sPrefix := '';

                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
              end;
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM8')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM8;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'byte ';

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{ru-sae},' else sSuffix := ', {ru-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM9' + sSuffix);
                  Item.Values.Add('XMM9');
                  Item.Values.Add(sPrefix + 'XMM18' + sSuffix);
                  Item.Values.Add('XMM18');
                  Item.Values.Add(sPrefix + 'XMM27' + sSuffix);
                  Item.Values.Add('XMM27');
                  Item.Values.Add(sPrefix + 'XMM31' + sSuffix);
                  Item.Values.Add('XMM31');
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
                  Item.Values.Add('XMM4');
                  Item.Values.Add(sPrefix + 'XMM8' + sSuffix);
                  Item.Values.Add('XMM8');
                  Item.Values.Add(sPrefix + 'XMM12' + sSuffix);
                  Item.Values.Add('XMM12');
                  Item.Values.Add(sPrefix + 'XMM15' + sSuffix);
                  Item.Values.Add('XMM15');
                end;

                //Item.Values.Add('[RIP]');
                //Item.Values.Add('[RIP + 16]');

                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
              end;
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM16')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM16;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'word ';

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{ru-sae},' else sSuffix := ', {ru-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'XMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM9' + sSuffix);
                  Item.Values.Add('XMM9');
                  Item.Values.Add(sPrefix + 'XMM18' + sSuffix);
                  Item.Values.Add('XMM18');
                  Item.Values.Add(sPrefix + 'XMM27' + sSuffix);
                  Item.Values.Add('XMM27');
                  Item.Values.Add(sPrefix + 'XMM31' + sSuffix);
                  Item.Values.Add('XMM31');
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'XMM0' + sSuffix);
                  Item.Values.Add('XMM0');
                  Item.Values.Add(sPrefix + 'XMM4' + sSuffix);
                  Item.Values.Add('XMM4');
                  Item.Values.Add(sPrefix + 'XMM8' + sSuffix);
                  Item.Values.Add('XMM8');
                  Item.Values.Add(sPrefix + 'XMM12' + sSuffix);
                  Item.Values.Add('XMM12');
                  Item.Values.Add(sPrefix + 'XMM15' + sSuffix);
                  Item.Values.Add('XMM15');
                end;

                //Item.Values.Add('[RIP]');
                //Item.Values.Add('[RIP + 16]');

                MemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else
              begin
                MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
              end;
            end
            else if (AnsiSameText(sl_Operand, 'YMMREG')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMReg;
              Item.OpActive := true;

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{rd-sae},' else sSuffix := ', {rd-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM9' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM18' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM27' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM31' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('YMM0');
                    Item.Values.Add('YMM9');
                    Item.Values.Add('YMM18');
                    Item.Values.Add('YMM27');
                    Item.Values.Add('YMM31');
                  end;
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM4' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM8' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM12' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM15' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('YMM0');
                    Item.Values.Add('YMM4');
                    Item.Values.Add('YMM8');
                    Item.Values.Add('YMM12');
                    Item.Values.Add('YMM15');
                  end;
                end;
              end;
            end
            else if (AnsiSameText(sl_Operand, 'YMMRM'))  or
                    (AnsiSameText(sl_Operand, 'YMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{rd-sae},' else sSuffix := ', {rd-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'YMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM9' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM18' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM27' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM31' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('YMM0');
                    Item.Values.Add('YMM9');
                    Item.Values.Add('YMM18');
                    Item.Values.Add('YMM27');
                    Item.Values.Add('YMM31');
                  end;
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'YMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM4' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM8' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM12' + sSuffix);
                  Item.Values.Add(sPrefix + 'YMM15' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('YMM0');
                    Item.Values.Add('YMM4');
                    Item.Values.Add('YMM8');
                    Item.Values.Add('YMM12');
                    Item.Values.Add('YMM15');
                  end;
                end;

                MemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
              end;
            end
            else if (AnsiSameText(sl_Operand, 'ZMMREG')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMReg;
              Item.OpActive := true;

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{rd-sae},' else sSuffix := ', {rd-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM9' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM18' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM27' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM31' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('ZMM0');
                    Item.Values.Add('ZMM9');
                    Item.Values.Add('ZMM18');
                    Item.Values.Add('ZMM27');
                    Item.Values.Add('ZMM31');
                  end;
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM4' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM8' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM12' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM15' + sSuffix);
                end;
              end;
              sPrefix := '';
            end
            else if (AnsiSameText(sl_Operand, 'ZMMRM')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';
              if FGas and noZSuffix then sl_Prefix := '';

              sSuffix := '';
              sPrefix := '';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
               else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then begin if FGas then sPrefix := '{rd-sae},' else sSuffix := ', {rd-sae}'; end
                else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then begin if FGas then sPrefix := '{sae},' else sSuffix := ', {sae}'; end;

              Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM1' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM2' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM3' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM4' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM5' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM6' + sSuffix);
              Item.Values.Add(sPrefix + 'ZMM7' + sSuffix);

              if x64 then
              begin
                Item.Values.Clear;
                if FAVX512 then
                begin
                  Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM9' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM18' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM27' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM31' + sSuffix);

                  if ((sPrefix <> '') or (sSuffix <> '')) and
		     (MaskRegNeeded = false)  then
                  begin
                    Item.Values.Add('ZMM0');
                    Item.Values.Add('ZMM9');
                    Item.Values.Add('ZMM18');
                    Item.Values.Add('ZMM27');
                    Item.Values.Add('ZMM31');
                  end;
                end
                else
                begin
                  Item.Values.Add(sPrefix + 'ZMM0' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM4' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM8' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM12' + sSuffix);
                  Item.Values.Add(sPrefix + 'ZMM15' + sSuffix);
                end;



                MemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
              end;
            end
            else if AnsiSameText(sl_Operand, 'MEM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM8;
              Item.OpActive := true;



	      if UsePrefix then sl_Prefix := 'byte ';


              sSuffix := '';

	      if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'MEM16') or
                    AnsiSameText(sl_Operand, 'MEM16_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM16;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'word ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'MEM32') or
                    AnsiSameText(sl_Operand, 'MEM32_M') or
                    AnsiSameText(sl_Operand, 'MEM32_MZ') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'dword ';
              if FGas and noZSuffix then sl_Prefix := '';

              sSuffix := '';

	      if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM64')) or
                    (AnsiSameText(sl_Operand, 'MEM64_M')) or
                    (AnsiSameText(sl_Operand, 'MEM64_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'qword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';

              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM128')) or
                    (AnsiSameText(sl_Operand, 'MEM128_M')) or
                    (AnsiSameText(sl_Operand, 'MEM128_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM128;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';

              if x64 then
              begin
                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM256')) or
                    (AnsiSameText(sl_Operand, 'MEM256_M')) or
                    (AnsiSameText(sl_Operand, 'MEM256_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM256;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM512')) or
                    (AnsiSameText(sl_Operand, 'MEM512_M')) or
                    (AnsiSameText(sl_Operand, 'MEM512_MZ')) or
                    (AnsiSameText(sl_Operand, 'SIBMEM')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM512;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';
              if FGas and noZSuffix then sl_Prefix := '';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'REG8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG8;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg8);
              end
              else Item.Values.AddStrings(FReg8);
            end
            else if AnsiSameText(sl_Operand, 'REG16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG16;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg16);
              end
              else Item.Values.AddStrings(FReg16);
            end
            else if AnsiSameText(sl_Operand, 'REG32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG32;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg32Base);
              end
              else Item.Values.AddStrings(FReg32Base);
            end
            else if AnsiSameText(sl_Operand, 'REG64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG64;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg64Base);
              end;
            end
            else if AnsiSameText(sl_Operand, 'RM16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM16;
              Item.OpActive := true;

              Item.Values.AddStrings(FReg16);

              if UsePrefix then sl_Prefix := 'word ';

              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'RM32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM32;
              Item.OpActive := true;

              Item.Values.AddStrings(FReg32Base);

              if UsePrefix then sl_Prefix := 'dword ';
              if FGas and noZSuffix then sl_Prefix := '';

              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'RM64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM32;
              Item.OpActive := true;



              if UsePrefix then sl_Prefix := 'qword ';

              if x64 then
              begin
                Item.Values.AddStrings(FReg64Base);
                MemRegBaseIndexCombi(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'IMM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otIMM8;
              Item.OpActive := true;

              if FGas then Item.Values.Add('$0') else Item.Values.Add('0');
            end
            else if AnsiSameText(sl_Operand, 'IMM32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otIMM8;
              Item.OpActive := true;

              if FGas then Item.Values.Add('$512') else Item.Values.Add('512');
            end
            else if AnsiSameText(sl_Operand, 'XMEM32') or
                    AnsiSameText(sl_Operand, 'XMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
		VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false) then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false) then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
              end;
            end
            else if AnsiSameText(sl_Operand, 'XMEM64') or
                    AnsiSameText(sl_Operand, 'XMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM64;
              Item.OpActive := true;

              //if UsePrefix then sl_Prefix := 'oword ';
              //
              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64XMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32XMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'YMEM32') or
                    AnsiSameText(sl_Operand, 'YMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'YMEM64') or
                    AnsiSameText(sl_Operand, 'YMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'ZMEM32') or
                    AnsiSameText(sl_Operand, 'ZMEM32_M')  then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';
              if FGas and noZSuffix then sl_Prefix := '';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'ZMEM64') or
                    AnsiSameText(sl_Operand, 'ZMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';
              if FGas and noZSuffix then sl_Prefix := '';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, '8B16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB16;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '16B16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB16;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '32B16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB16;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to32}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to32}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '2B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '4B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '8B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '16B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '2B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '4B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '8B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '16B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombi(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombi(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'KREG') or
                    AnsiSameText(sl_Operand, 'KREG_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otKREG;
              Item.OpActive := true;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if UsePrefix then sl_Prefix := '';

              for i := 0 to FRegKREG.Count - 1 do
               Item.Values.Add(FRegKREG[i] + sSuffix);
            end
            else if trim(sl_Operand) = '' then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('');
            end
            else
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('?' + sl_Operand);
            end

          end;

          sl_RegCombi := '';


          il_Operands := 0;
          UsedParams  := 0;

          if OItem1.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 1;
          end;

          if OItem2.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 2;
          end;

          if OItem3.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 4;
          end;

          if OItem4.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 8;
          end;

          case il_Operands of
              1: UseDefault := UsedParams <> 1;
              2: UseDefault := UsedParams <> 3;
              3: UseDefault := UsedParams <> 7;
              4: UseDefault := UsedParams <> 15;
            else UseDefault := true;
          end;

          //UseDefault := true;

          if UseDefault then
          begin
            sl_Inst := format('%-20s', [aInst]);

            for il_Op1 := 0 to OItem1.Values.Count - 1 do
            begin
              for il_Op2 := 0 to OItem2.Values.Count - 1 do
              begin
                for il_Op3 := 0 to OItem3.Values.Count - 1 do
                begin
                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
                  begin
                    sl_RegCombi := '';
                    sl_Reg1 := '';
                    sl_Reg2 := '';
                    sl_Reg3 := '';

                    if OItem1.OpActive then
                    begin
                      sl_RegCombi1:=OItem1.Values[il_Op1];
                      if EvenPair then sl_RegCombi1:=EvenOddPairReg (sl_RegCombi1);
                      if sl_RegCombi <> '' then if FGas then sl_RegCombi := ', ' + sl_RegCombi  else sl_RegCombi := sl_RegCombi + ', ';
                      if FGas then sl_RegCombi := sl_RegCombi1 + sl_RegCombi else sl_RegCombi := sl_RegCombi + sl_RegCombi1;
                      if Distinct then sl_Reg1:=ExtractReg(OItem1.Values[il_Op1]);
                    end;

                    if OItem2.OpActive then
                    begin
                      sl_RegCombi2:=OItem2.Values[il_Op2];
                      if GroupOf4 then sl_RegCombi2:=GroupOf4Reg( sl_RegCombi2 );
                      if sl_RegCombi <> '' then if FGas then sl_RegCombi := ', ' + sl_RegCombi  else sl_RegCombi := sl_RegCombi + ', ';
                      if FGas then sl_RegCombi := sl_RegCombi2 + sl_RegCombi else sl_RegCombi := sl_RegCombi + sl_RegCombi2;
                      if Distinct then sl_Reg1:=ExtractReg(OItem2.Values[il_Op2]);
                    end;

                    if OItem3.OpActive then
                    begin
                      if sl_RegCombi <> '' then if FGas then sl_RegCombi := ', ' + sl_RegCombi  else sl_RegCombi := sl_RegCombi + ', ';
                      if FGas then sl_RegCombi := OItem3.Values[il_Op3] + sl_RegCombi else sl_RegCombi := sl_RegCombi + OItem3.Values[il_Op3];
                      if Distinct then sl_Reg1:=ExtractReg(OItem3.Values[il_Op3]);
                    end;

                    if OItem4.OpActive then
                    begin
                      if sl_RegCombi <> '' then if FGas then sl_RegCombi := ', ' + sl_RegCombi  else sl_RegCombi := sl_RegCombi + ', ';
                      if FGas then sl_RegCombi := OItem4.Values[il_Op4] + sl_RegCombi else sl_RegCombi := sl_RegCombi + OItem4.Values[il_Op4];
                    end;

                    if sl_RegCombi <> '' then
                    begin
                      if not Distinct or (Distinct and notEqualRegs (sl_Reg1,sl_Reg2,sl_Reg3) ) then
                      if not DistinctAll or (DistinctAll and notEqualRegs (sl_Reg2,sl_Reg3,'') ) then
                      begin
                        if FGas then sl_RegCombi := ConvertToGasReg(sl_RegCombi);
                        if not FGas then
                           result.Add(sl_Inst + sl_RegCombi)
                        else
                        begin
                          sPtr:=MemPtr(sl_RegCombi);
                          result.Add(aInst + sPtr + '   ' + sl_RegCombi)
                        end;
                      end;
                      sl_RegCombi := '';
                    end;
                  end;
                end;
              end;
            end;
          end
          else
          begin
            sl_Inst := format('%-20s', [aInst]);

            for il_Op1 := 0 to OItem1.Values.Count - 1 do
            begin
              sl_Reg1:='';
              if OItem1.OpActive then
              begin
                sl_RegCombi1:=OItem1.Values[il_Op1];
                if EvenPair then sl_RegCombi1:=EvenOddPairReg (sl_RegCombi1);
                if Distinct then sl_Reg1:=ExtractReg(OItem1.Values[il_Op1]);
              end
              else sl_RegCombi1 := '';

              for il_Op2 := 0 to OItem2.Values.Count - 1 do
              begin
                sl_Reg2:='';
                if OItem2.OpActive then
                begin
                  sl_RegCombi2:=OItem2.Values[il_Op2];
                  if GroupOf4 then sl_RegCombi2:=GroupOf4Reg( sl_RegCombi2 );
                  if FGas then sl_RegCombi2 := sl_RegCombi2 + ', ' + sl_RegCombi1 else sl_RegCombi2 := sl_RegCombi1 + ', ' + sl_RegCombi2;
                  if Distinct then sl_Reg2:=ExtractReg(OItem2.Values[il_Op2]);
                end
                else sl_RegCombi2 := sl_RegCombi1;

                for il_Op3 := 0 to OItem3.Values.Count - 1 do
                begin
                  sl_Reg3:='';
                  if OItem3.OpActive then
                  begin
                    if FGas then sl_RegCombi3 := OItem3.Values[il_Op3] + ', ' + sl_RegCombi2 else sl_RegCombi3 := sl_RegCombi2 + ', ' + OItem3.Values[il_Op3];
                    if Distinct then sl_Reg3:=ExtractReg(OItem3.Values[il_Op3]);
                  end
                  else sl_RegCombi3 := sl_RegCombi2;

                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
                  begin
                    if OItem4.OpActive then
                    begin
                      if FGas then sl_RegCombi := OItem4.Values[il_Op4] + ', ' + sl_RegCombi3 else sl_RegCombi := sl_RegCombi3 + ', ' + OItem4.Values[il_Op4];
                    end
                    else sl_RegCombi := sl_RegCombi3;

                    if sl_RegCombi <> '' then
                    begin
                      //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
                      if not Distinct or (Distinct and notEqualRegs (sl_Reg1,sl_Reg2,sl_Reg3) ) then
                      if not DistinctAll or (DistinctAll and notEqualRegs (sl_Reg2,sl_Reg3,'') ) then
                      begin
                        if FGas then sl_RegCombi := ConvertToGasReg(sl_RegCombi);
                        if not FGas then
                           result.Add(sl_Inst + sl_RegCombi)
                        else
                        begin
                          sPtr:=MemPtr(sl_RegCombi);
                          result.Add(aInst + sPtr + '   ' + sl_RegCombi)
                        end;
                      end;
                      sl_RegCombi := '';
                    end;
                  end;
                end;
              end;
            end;
          end;
        finally
          FreeAndNil(OItem4);
        end;
      finally
        FreeAndNil(OItem3);
      end;
    finally
      FreeAndNil(OItem2);
    end;
  finally
    FreeAndNil(OItem1);
  end;
end;


function TAsmTestGenerator.InternalCalcTestDataMREF(const aInst, aOp1, aOp2, aOp3,
  aOp4: String): TStringList;
var
  i: integer;
  Item: TOperandListItem;
  OItem1: TOperandListItem;
  OItem2: TOperandListItem;
  OItem3: TOperandListItem;
  OItem4: TOperandListItem;

  il_Op: integer;
  il_Op1: integer;
  il_Op2: integer;
  il_Op3: integer;
  il_Op4: integer;

  sSuffix: string;
  sl_Operand: String;
  sl_Inst   : String;
  sl_RegCombi: String;
  sl_Prefix: String;
  UsePrefix: boolean;
  il_Operands: integer;
  UsedParams: cardinal;
  UseDefault: boolean;
  sl_RegCombi1: string;
  sl_RegCombi2: string;
  sl_RegCombi3: string;

  function PrepareOperandTyp(const aTyp: String): String;
  begin
    result := aTyp;
    if copy(result, length(result), 1) = '*' then result := copy(result, 1, length(result) - 1);
    if result = 'XMMRM128' then result := 'XMMRM';
    if result = 'YMMRM256' then result := 'YMMRM';
  end;


begin
  result := TStringList.Create;

  OItem1 := TOperandListItem.Create;
  try
    OItem2 := TOperandListItem.Create;
    try
      OItem3 := TOperandListItem.Create;
      try
        OItem4 := TOperandListItem.Create;
        try

          UsePrefix := (UpperCase(aInst) = 'VCVTPD2DQ') OR
                       (UpperCase(aInst) = 'VCVTPD2PS') OR
                       (UpperCase(aInst) = 'VCVTSI2SD') OR
                       (UpperCase(aInst) = 'VCVTSI2SS') OR
                       (UpperCase(aInst) = 'VCVTTPD2DQ') or
                       (UpperCase(aInst) = 'VPMOVZXWQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTUQQ2PS') or
                       (UpperCase(aInst) = 'VCVTQQ2PS') or
                       (UpperCase(aInst) = 'VCVTUSI2SD') or
                       (UpperCase(aInst) = 'VCVTUSI2SS') or
                       (UpperCase(aInst) = 'VFPCLASSPD') or
                       (UpperCase(aInst) = 'VFPCLASSPS') or
                       (UpperCase(aInst) = 'VCMPSS')

                       ;



          for il_Op := 1 to 4 do
          begin
            sl_Prefix := '';

            case il_Op of
              1: begin
                   Item := OItem1;
                   sl_Operand := aOp1;
                 end;
              2: begin
                   Item := OItem2;
                   sl_Operand := aOp2;
                 end;
              3: begin
                   Item := OItem3;
                   sl_Operand := aOp3;
                 end;
              4: begin
                   Item := OItem4;
                   sl_Operand := aOp4;
                 end;
            end;

            sl_Operand := PrepareOperandTyp(sl_Operand);

            if (AnsiSameText(sl_Operand, 'XMMREG')) or
               (AnsiSameText(sl_Operand, 'XMMREG_M')) or
               (AnsiSameText(sl_Operand, 'XMMREG_MZ')) or
               (AnsiSameText(sl_Operand, 'XMMREG_ER')) or
               (AnsiSameText(sl_Operand, 'XMMREG_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMReg;
              Item.OpActive := true;

              Item.Values.Add('XMM0');
           end
            else if (AnsiSameText(sl_Operand, 'XMMRM')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              Item.Values.Add(' lOWord');
              Item.Values.Add(' gOWord');
              Item.Values.Add(' clOWord');
              Item.Values.Add(' cgOWord');

              Item.Values.Add(' oword lOWord');
              Item.Values.Add(' oword gOWord');
              Item.Values.Add(' oword clOWord');
              Item.Values.Add(' oword cgOWord');

              Item.Values.Add(' byte lOWord');
              Item.Values.Add(' byte gOWord');
              Item.Values.Add(' byte clOWord');
              Item.Values.Add(' byte cgOWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' oword lRec');
              Item.Values.Add(' oword gRec');

              Item.Values.Add(' oword lRec.rOWord');
              Item.Values.Add(' oword gRec.rOWord');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'XMMRM8')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM8;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'byte ';

              Item.Values.Add('lbyte');
              Item.Values.Add('gbyte');
              Item.Values.Add('clbyte');
              Item.Values.Add('cgbyte');

              Item.Values.Add('byte lbyte');
              Item.Values.Add('byte gbyte');
              Item.Values.Add('byte clbyte');
              Item.Values.Add('byte cgbyte');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' byte lRec');
              Item.Values.Add(' byte gRec');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'XMMRM16')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM16;
              Item.OpActive := true;

              Item.Values.Add('lword');
              Item.Values.Add('gword');
              Item.Values.Add('clword');
              Item.Values.Add('cgword');

              Item.Values.Add('word lword');
              Item.Values.Add('word gword');
              Item.Values.Add('word clword');
              Item.Values.Add('word cgword');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' word lRec');
              Item.Values.Add(' word gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'YMMREG')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMReg;
              Item.OpActive := true;

              Item.Values.Add('YMM0');
            end
            else if (AnsiSameText(sl_Operand, 'YMMRM'))  or
                    (AnsiSameText(sl_Operand, 'YMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMRM;
              Item.OpActive := true;

              Item.Values.Add('lYWord');
              Item.Values.Add('gYWord');
              Item.Values.Add('clYWord');
              Item.Values.Add('cgYWord');

              Item.Values.Add('yword lYWord');
              Item.Values.Add('yword gYWord');
              Item.Values.Add('yword clYWord');
              Item.Values.Add('yword cgYWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' yword lRec');
              Item.Values.Add(' yword gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'ZMMREG')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMReg;
              Item.OpActive := true;

              Item.Values.Add('ZMM0');
            end
            else if (AnsiSameText(sl_Operand, 'ZMMRM')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMRM;
              Item.OpActive := true;

              Item.Values.Add('lZWord');
              Item.Values.Add('gZWord');
              Item.Values.Add('clZWord');
              Item.Values.Add('cgZWord');

              Item.Values.Add('zword lZWord');
              Item.Values.Add('zword gZWord');
              Item.Values.Add('zword clZWord');
              Item.Values.Add('zword cgZWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' zword lRec');
              Item.Values.Add(' zword gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if AnsiSameText(sl_Operand, 'MEM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM8;
              Item.OpActive := true;

              Item.Values.Add('lByte');
              Item.Values.Add('gByte');
              Item.Values.Add('clByte');
              Item.Values.Add('cgByte');

              Item.Values.Add('byte lByte');
              Item.Values.Add('byte gByte');
              Item.Values.Add('byte clByte');
              Item.Values.Add('byte cgByte');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' byte lRec');
              Item.Values.Add(' byte gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');
            end
            else if AnsiSameText(sl_Operand, 'MEM16') or
                    AnsiSameText(sl_Operand, 'MEM16_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM16;
              Item.OpActive := true;

              Item.Values.Add('lWord');
              Item.Values.Add('gWord');
              Item.Values.Add('clWord');
              Item.Values.Add('cgWord');

              Item.Values.Add('word lWord');
              Item.Values.Add('word gWord');
              Item.Values.Add('word clWord');
              Item.Values.Add('word cgWord');

              Item.Values.Add(' word lRec');
              Item.Values.Add(' word gRec');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');
            end
            else if AnsiSameText(sl_Operand, 'MEM32') or
                    AnsiSameText(sl_Operand, 'MEM32_M') or
                    AnsiSameText(sl_Operand, 'MEM32_MZ') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM32;
              Item.OpActive := true;

              Item.Values.Add('lDWord');
              Item.Values.Add('gDWord');
              Item.Values.Add('clDWord');
              Item.Values.Add('cgDWord');

              Item.Values.Add('dword lDWord');
              Item.Values.Add('dword gDWord');
              Item.Values.Add('dword clDWord');
              Item.Values.Add('dword cgDWord');

              Item.Values.Add(' dword lRec');
              Item.Values.Add(' dword gRec');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');
            end
            else if (AnsiSameText(sl_Operand, 'MEM64')) or
                    (AnsiSameText(sl_Operand, 'MEM64_M')) or
                    (AnsiSameText(sl_Operand, 'MEM64_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM64;
              Item.OpActive := true;

              Item.Values.Add('lQWord');
              Item.Values.Add('gQWord');
              Item.Values.Add('clQWord');
              Item.Values.Add('cgQWord');

              Item.Values.Add('qword lQWord');
              Item.Values.Add('qword gQWord');
              Item.Values.Add('qword clQWord');
              Item.Values.Add('qword cgQWord');

              Item.Values.Add(' qword lRec');
              Item.Values.Add(' qword gRec');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');
            end
            else if (AnsiSameText(sl_Operand, 'MEM128')) or
                    (AnsiSameText(sl_Operand, 'MEM128_M')) or
                    (AnsiSameText(sl_Operand, 'MEM128_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM128;
              Item.OpActive := true;

              Item.Values.Add('lOWord');
              Item.Values.Add('gOWord');
              Item.Values.Add('clOWord');
              Item.Values.Add('cgOWord');

              Item.Values.Add('oword lOWord');
              Item.Values.Add('oword gOWord');
              Item.Values.Add('oword clOWord');
              Item.Values.Add('oword cgOWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' oword lRec');
              Item.Values.Add(' oword gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'MEM256')) or
                    (AnsiSameText(sl_Operand, 'MEM256_M')) or
                    (AnsiSameText(sl_Operand, 'MEM256_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM256;
              Item.OpActive := true;

              Item.Values.Add('lYWord');
              Item.Values.Add('gYWord');
              Item.Values.Add('clYWord');
              Item.Values.Add('cgYWord');

              Item.Values.Add('yword lYWord');
              Item.Values.Add('yword gYWord');
              Item.Values.Add('yword clYWord');
              Item.Values.Add('yword cgYWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' yword lRec');
              Item.Values.Add(' yword gRec');

              Item.Values.Add(' lRec.rByte');
              Item.Values.Add(' gRec.rByte');

              Item.Values.Add(' lRec.rWord');
              Item.Values.Add(' gRec.rWord');

              Item.Values.Add(' lRec.rDWord');
              Item.Values.Add(' gRec.rDWord');

              Item.Values.Add(' lRec.rQWord');
              Item.Values.Add(' gRec.rQWord');

              Item.Values.Add(' lRec.rOWord');
              Item.Values.Add(' gRec.rOWord');

              Item.Values.Add(' lRec.rYWord');
              Item.Values.Add(' gRec.rYWord');

              Item.Values.Add(' lRec.rZWord');
              Item.Values.Add(' gRec.rZWord');

            end
            else if (AnsiSameText(sl_Operand, 'MEM512')) or
                    (AnsiSameText(sl_Operand, 'MEM512_M')) or
                    (AnsiSameText(sl_Operand, 'MEM512_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM512;
              Item.OpActive := true;

              Item.Values.Add('lZWord');
              Item.Values.Add('gZWord');
              Item.Values.Add('clZWord');
              Item.Values.Add('cgZWord');

              Item.Values.Add('zword lZWord');
              Item.Values.Add('zword gZWord');
              Item.Values.Add('zword clZWord');
              Item.Values.Add('zword cgZWord');

              Item.Values.Add(' lRec');
              Item.Values.Add(' gRec');

              Item.Values.Add(' zword lRec');
              Item.Values.Add(' zword gRec');


            end
            else if AnsiSameText(sl_Operand, 'REG8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG8;
              Item.OpActive := true;

              Item.Values.Add('al');
            end
            else if AnsiSameText(sl_Operand, 'REG16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG16;
              Item.OpActive := true;

              Item.Values.Add('ax');
            end
            else if AnsiSameText(sl_Operand, 'REG32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG32;
              Item.OpActive := true;

              Item.Values.Add('eax');
            end
            else if AnsiSameText(sl_Operand, 'REG64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG64;
              Item.OpActive := true;

              Item.Values.Add('rax');
            end
            else if AnsiSameText(sl_Operand, 'RM32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM32;
              Item.OpActive := true;

              Item.Values.Add('lDWord');
              Item.Values.Add('gDWord');
            end
            else if AnsiSameText(sl_Operand, 'RM64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM64;
              Item.OpActive := true;

              Item.Values.Add('lQWord');
              Item.Values.Add('gQWord');
            end
            else if AnsiSameText(sl_Operand, 'IMM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otIMM8;
              Item.OpActive := true;

              if FGas then Item.Values.Add('$0') else Item.Values.Add('0');
            end
            else if AnsiSameText(sl_Operand, 'XMEM32') or
                    AnsiSameText(sl_Operand, 'XMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM32;
              Item.OpActive := true;
            end
            else if AnsiSameText(sl_Operand, 'XMEM64') or
                    AnsiSameText(sl_Operand, 'XMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM64;
              Item.OpActive := true;
            end
            else if AnsiSameText(sl_Operand, 'YMEM32') or
                    AnsiSameText(sl_Operand, 'YMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM32;
              Item.OpActive := true;
            end
            else if AnsiSameText(sl_Operand, 'YMEM64') or
                    AnsiSameText(sl_Operand, 'YMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

            end
            else if AnsiSameText(sl_Operand, 'ZMEM32') or
                    AnsiSameText(sl_Operand, 'ZMEM32_M')  then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

            end
            else if AnsiSameText(sl_Operand, 'ZMEM64') or
                    AnsiSameText(sl_Operand, 'ZMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

            end
            else if AnsiSameText(sl_Operand, '2B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;

              Item.Values.Add('lDWord {1to2}');
              Item.Values.Add('gDWord {1to2}');
            end
            else if AnsiSameText(sl_Operand, '4B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;

              Item.Values.Add('lDWord {1to4}');
              Item.Values.Add('gDWord {1to4}');
            end
            else if AnsiSameText(sl_Operand, '8B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;

              Item.Values.Add('lDWord {1to8}');
              Item.Values.Add('gDWord {1to8}');
            end
            else if AnsiSameText(sl_Operand, '16B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;

              Item.Values.Add('lDWord {1to16}');
              Item.Values.Add('gDWord {1to16}');
           end
            else if AnsiSameText(sl_Operand, '2B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;

              Item.Values.Add('lQWord {1to2}');
              Item.Values.Add('gQWord {1to2}');
            end
            else if AnsiSameText(sl_Operand, '4B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;

              Item.Values.Add('lQWord {1to4}');
              Item.Values.Add('gQWord {1to4}');
            end
            else if AnsiSameText(sl_Operand, '8B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;

              Item.Values.Add('lQWord {1to8}');
              Item.Values.Add('gQWord {1to8}');
            end
            else if AnsiSameText(sl_Operand, '16B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;

              Item.Values.Add('lQWord {1to16}');
              Item.Values.Add('gQWord {1to16}');
           end
            else if AnsiSameText(sl_Operand, 'KREG') or
                    AnsiSameText(sl_Operand, 'KREG_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otKREG;
              Item.OpActive := true;

              Item.Values.Add('k1');
            end
            else if trim(sl_Operand) = '' then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('');
            end
            else
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('?' + sl_Operand);
            end

          end;

          sl_RegCombi := '';


          il_Operands := 0;
          UsedParams  := 0;

          if OItem1.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 1;
          end;

          if OItem2.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 2;
          end;

          if OItem3.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 4;
          end;

          if OItem4.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 8;
          end;

          case il_Operands of
              1: UseDefault := UsedParams <> 1;
              2: UseDefault := UsedParams <> 3;
              3: UseDefault := UsedParams <> 7;
              4: UseDefault := UsedParams <> 15;
            else UseDefault := true;
          end;

          //UseDefault := true;

          if UseDefault then
          begin
            sl_Inst := format('%-20s', [aInst]);

            for il_Op1 := 0 to OItem1.Values.Count - 1 do
            begin
              for il_Op2 := 0 to OItem2.Values.Count - 1 do
              begin
                for il_Op3 := 0 to OItem3.Values.Count - 1 do
                begin
                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
                  begin
                    sl_RegCombi := '';

                    if OItem1.OpActive then
                    begin
                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                      sl_RegCombi := sl_RegCombi + OItem1.Values[il_Op1];
                    end;

                    if OItem2.OpActive then
                    begin
                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                      sl_RegCombi := sl_RegCombi + OItem2.Values[il_Op2];
                    end;

                    if OItem3.OpActive then
                    begin
                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                      sl_RegCombi := sl_RegCombi + OItem3.Values[il_Op3];
                    end;

                    if OItem4.OpActive then
                    begin
                      if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                      sl_RegCombi := sl_RegCombi + OItem4.Values[il_Op4];
                    end;

                    if sl_RegCombi <> '' then
                    begin
                      //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
                      result.Add(sl_Inst + sl_RegCombi);
                      sl_RegCombi := '';
                    end;
                  end;
                end;
              end;
            end;
          end
          else
          begin
            sl_Inst := format('%-20s', [aInst]);

            for il_Op1 := 0 to OItem1.Values.Count - 1 do
            begin
              if OItem1.OpActive then
              begin
                sl_RegCombi1 := OItem1.Values[il_Op1];
              end
              else sl_RegCombi1 := '';

              for il_Op2 := 0 to OItem2.Values.Count - 1 do
              begin
                if OItem2.OpActive then
                begin
                  sl_RegCombi2 := sl_RegCombi1 + ', ' + OItem2.Values[il_Op2];
                end
                else sl_RegCombi2 := sl_RegCombi1;

                for il_Op3 := 0 to OItem3.Values.Count - 1 do
                begin
                  if OItem3.OpActive then
                  begin
                    sl_RegCombi3 := sl_RegCombi2 + ', ' + OItem3.Values[il_Op3];
                  end
                  else sl_RegCombi3 := sl_RegCombi2;

                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
                  begin
                    if OItem4.OpActive then
                    begin
                      sl_RegCombi := sl_RegCombi3 + ', ' + OItem4.Values[il_Op4];
                    end
                    else sl_RegCombi := sl_RegCombi3;

                    if sl_RegCombi <> '' then
                    begin
                      //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
                      result.Add(sl_Inst + sl_RegCombi);
                      sl_RegCombi := '';
                    end;
                  end;
                end;
              end;
            end;
          end;
        finally
          FreeAndNil(OItem4);
        end;
      finally
        FreeAndNil(OItem3);
      end;
    finally
      FreeAndNil(OItem2);
    end;
  finally
    FreeAndNil(OItem1);
  end;
end;

function TAsmTestGenerator.InternalCalcTestDataCDISP8(const aInst, aOp1, aOp2,
  aOp3, aOp4: String): TStringList;
var
  i: integer;
  Item: TOperandListItem;
  OItem1: TOperandListItem;
  OItem2: TOperandListItem;
  OItem3: TOperandListItem;
  OItem4: TOperandListItem;

  il_Op: integer;
  il_Op1: integer;
  il_Op2: integer;
  il_Op3: integer;
  il_Op4: integer;
  iAsmCounter: integer;

  sSuffix: string;
  sReg: string;
  sl_Operand: String;
  sl_Inst   : String;
  sRegCombi: String;
  sRegCombi1: String;
  sRegCombi2: String;
  sRegCombi3: String;
  sRegCombi4: String;
  sBaseReg  : String;
  sIndexReg : String;

  sl_Prefix: String;
  UsePrefix: boolean;
  il_Operands: integer;
  UsedParams: cardinal;
  UseDefault: boolean;
  sl_RegCombi1: string;
  sl_RegCombi2: string;
  sl_RegCombi3: string;
  sInstruction: string;
  sMREF: string;
  sLogMsg: string;
  MaskRegNeeded:boolean;
  slRegCombi: TStringList;
  OpMode: TOpMode;
  iOpNumMRef: integer;

  function PrepareOperandTyp(const aTyp: String): String;
  begin
    result := aTyp;
    if copy(result, length(result), 1) = '*' then result := copy(result, 1, length(result) - 1);
    if result = 'XMMRM128' then result := 'XMMRM';
    if result = 'YMMRM256' then result := 'YMMRM';
  end;

  procedure SplitOperands(const aOperand1, aOperand2, aOperand3, aOperand4: string; var aRegCombi0, aRegCombi1, aRegCombi2, aRegCombi3, aRegCombi4: string);
  var
    i: integer;
    s1: string;
    s2: string;
    s3: string;
    s4: string;
    iCnt1: integer;
    iCnt2: integer;
    iCnt3: integer;
    iCnt4: integer;
    iMaxCnt: integer;

  begin
    with TStringList.Create do
    try
      Text := StringReplace(trim(aOperand1), '|', #13#10, [rfReplaceAll]);
      iCnt1 := Count;

      Text := StringReplace(trim(aOperand2), '|', #13#10, [rfReplaceAll]);
      iCnt2 := Count;

      Text := StringReplace(trim(aOperand3), '|', #13#10, [rfReplaceAll]);
      iCnt3 := Count;

      Text := StringReplace(trim(aOperand4), '|', #13#10, [rfReplaceAll]);
      iCnt4 := Count;

      iMaxCnt := iCnt1;
      if iCnt2 > iMaxCnt then iMaxCnt := iCnt2;
      if iCnt3 > iMaxCnt then iMaxCnt := iCnt3;
      if iCnt4 > iMaxCnt then iMaxCnt := iCnt4;


      if (aOperand1 <> '') and (aRegCombi0 <> '') then
      begin
        aRegCombi0 := aRegCombi0 + ',';
        aRegCombi1 := aRegCombi1 + ',';
        aRegCombi2 := aRegCombi2 + ',';
        aRegCombi3 := aRegCombi3 + ',';
        aRegCombi4 := aRegCombi4 + ',';
      end;


      Text := StringReplace(trim(aOperand1), '|', #13#10, [rfReplaceAll]);
      if Count = iMaxCnt then
      begin
        for i := 0 to iMaxCnt - 1 do
        begin
          case i of
            0: aRegCombi0 := aRegCombi0 + ',' + Strings[i];
            1: aRegCombi1 := aRegCombi1 + ',' + Strings[i];
            2: aRegCombi2 := aRegCombi2 + ',' + Strings[i];
            3: aRegCombi3 := aRegCombi3 + ',' + Strings[i];
            4: aRegCombi4 := aRegCombi4 + ',' + Strings[i];
          end;
        end;
      end
      else
      begin
        if Count = 1 then
        begin
          for i := 0 to iMaxCnt - 1 do
          begin
            case i of
              0: aRegCombi0 := aRegCombi0 + ',' + Strings[0];
              1: aRegCombi1 := aRegCombi1 + ',' + Strings[0];
              2: aRegCombi2 := aRegCombi2 + ',' + Strings[0];
              3: aRegCombi3 := aRegCombi3 + ',' + Strings[0];
              4: aRegCombi4 := aRegCombi4 + ',' + Strings[0];
            end;
          end;
        end
        else
        begin
          // TODO log
        end;
      end;
    finally
      Free;
    end;
  end;

  function MapOperand(aOpTyp: TOpType): String;
  begin
    case aOpTyp of
        otXMMReg: result := 'X';
        otYMMReg: result := 'Y';
        otZMMReg: result := 'Z';
           otEAX,
           otRAX,
         otREG64,
         otREG32,
         otREG16,
          otREG8: result := 'R';
          otRM32,
          otRM64,
         otXMMRM,
        otXMMRM8,
       otXMMRM16,
         otYMMRM,
         otZMMRM,
         otMem32,
          otMem8,
         otMem16,
         otMem64,
        otMem128,
        otMem256,
        otMem512: result := 'M';
          otIMM8: result := 'I';
        otXMEM32: result := 'X32';
        otXMEM64: result := 'X64';
        otYMEM32: result := 'Y32';
        otYMEM64: result := 'Y64';
        otZMEM32: result := 'Z32';
        otZMEM64: result := 'Z64';
           otB16: result := 'B16';
           otB32: result := 'B32';
           otB64: result := 'B64';
          otKREG: result := 'K';
             else result := '';
    end;
  end;

  function AsmCodeBlockCompare(aAsmCounter: integer; aCompareMode: TAsmCompareMode): String;
  var
    sReg: string;
  begin
    result := '';

    case Fx64 of
      true: sReg := 'RAX';
       else sReg := 'EAX';
    end;

    with TStringList.Create do
    try
      Add(format('%20s%6s  ',             ['    push', sReg]));
      Add(format('%20s%6s,%s',            ['     mov', sReg, inttostr(aAsmCounter)]));
      Add(format('%20s%6s,%s',            ['   kmovd', 'K7', 'EAX']));
      Add(format('%20s%6s',               ['     pop', sReg]));

      case aComparemode of
        //cmKORTESTNC: begin
        //               Add(format('%20s%6s, %s',           ['ktestb', 'K2', 'K1']));
        //               Add(format('%20s  %6s',             ['     jnc', '@@CHECKRESULT']));
        //             end;
        //cmXORTestNZ: begin
        //               Add(format('%20s%6s, %s',           ['kortestq', 'K2', 'K2']));
        //               Add(format('%20s  %6s',             ['     jnz', '@@CHECKRESULT']));
        //             end;
         cmKORTESTNC: begin
                        Add(format('%20s%6s, %s',           ['ktestb', 'K2', 'K1']));
                        Add(format('%20s%6s, %s',           [' kmovq', 'R10', 'K6']));
                        Add(format('%20s%6s, @@%d[RIP]',    ['cmovc', 'R10', aAsmCounter]));
                        Add(format('%20s  %6s',             ['  jmp', 'R10']));
                        Add(format('        @@%d%s',               [aAsmCounter, ':']));
                      end;
         cmXORTestNZ: begin
                        Add(format('%20s%6s, %s',           ['kortestq', 'K2', 'K2']));
                        Add(format('%20s%6s, %s',           [' kmovq', 'R10', 'K6']));
                        Add(format('%20s%6s, @@%d[RIP]',    ['cmovz', 'R10', aAsmCounter]));
                        Add(format('%20s  %6s',             ['  jmp', 'R10']));
                        Add(format('        @@%d%s',         [aAsmCounter, ':']));
                      end;

      end;

      result := Text;
    finally
      Free;
    end;
  end;

begin
  result := TStringList.Create;

  iAsmCounter := 0;

  OItem1 := TOperandListItem.Create;
  try
    OItem2 := TOperandListItem.Create;
    try
      OItem3 := TOperandListItem.Create;
      try
        OItem4 := TOperandListItem.Create;
        try

          UsePrefix := (UpperCase(aInst) = 'VCVTPD2DQ') OR
                       (UpperCase(aInst) = 'VCVTPD2PS') OR
                       (UpperCase(aInst) = 'VCVTSI2SD') OR
                       (UpperCase(aInst) = 'VCVTSI2SS') OR
                       (UpperCase(aInst) = 'VCVTTPD2DQ') or
                       (UpperCase(aInst) = 'VPMOVZXWQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTTPD2UDQ') or
                       (UpperCase(aInst) = 'VCVTUQQ2PS') or
                       (UpperCase(aInst) = 'VCVTQQ2PS') or
                       (UpperCase(aInst) = 'VCVTUSI2SD') or
                       (UpperCase(aInst) = 'VCVTUSI2SS') or
                       (UpperCase(aInst) = 'VFPCLASSPD') or
                       (UpperCase(aInst) = 'VFPCLASSPS') or
                       (UpperCase(aInst) = 'VCMPSS')

                       ;


          MaskRegNeeded := (Pos('VGATHER', Uppercase(aInst)) = 1) or
                           (Pos('VPGATHER', Uppercase(aInst)) = 1) or
			   (Pos('VPSCATTER', Uppercase(aInst)) = 1) or
			   (Pos('VSCATTER', Uppercase(aInst)) = 1);

          for il_Op := 1 to 4 do
          begin
            sl_Prefix := '';

            case il_Op of
              1: begin
                   Item := OItem1;
                   sl_Operand := aOp1;
                 end;
              2: begin
                   Item := OItem2;
                   sl_Operand := aOp2;
                 end;
              3: begin
                   Item := OItem3;
                   sl_Operand := aOp3;
                 end;
              4: begin
                   Item := OItem4;
                   sl_Operand := aOp4;
                 end;
            end;

            sl_Operand := PrepareOperandTyp(sl_Operand);

            if (AnsiSameText(sl_Operand, 'XMMREG')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMReg;
              Item.OpActive := true;

              Item.Values.Add('XMM16');
            end
            else if (AnsiSameText(sl_Operand, 'XMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'XMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMREG_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMReg;
              Item.OpActive := true;

              //sSuffix := '';
              //if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
              // else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              //
              //if Pos('_ER', sl_Operand) > 0 then sSuffix := ', {ru-sae}'
              // else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
              //
              //Item.Values.Add('XMM0' + sSuffix);
              //if (sSuffix <> '') and
              //   (MaskRegNeeded = false) then Item.Values.Add('XMM0');

              Item.Values.Add('XMM16');
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              if x64 then MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
               else MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM8')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM8_SAE')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM8;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'byte ';

              if x64 then MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
               else MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'XMMRM16')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_M')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_MZ')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_ER')) or
                    (AnsiSameText(sl_Operand, 'XMMRM16_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMMRM16;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'word ';

              if x64 then MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
               else MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'YMMREG')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMReg;
              Item.OpActive := true;

              Item.Values.Add('YMM16');
            end
            else if (AnsiSameText(sl_Operand, 'YMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMReg;
              Item.OpActive := true;

              //sSuffix := '';
              //if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
              // else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              //
              //if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
              // else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';
              //
              //Item.Values.Add('YMM0' + sSuffix);
              //if (sSuffix <> '') and
              //   (MaskRegNeeded = false) then Item.Values.Add('YMM0');

              Item.Values.Add('YMM16');
            end
            else if (AnsiSameText(sl_Operand, 'YMMRM'))  or
                    (AnsiSameText(sl_Operand, 'YMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'YMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              //sSuffix := '';
              //if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
              // else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              //
              //if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
              // else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';

              if x64 then MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
               else MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'ZMMREG')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMReg;
              Item.OpActive := true;

              Item.Values.Add('ZMM16');
            end
            else if (AnsiSameText(sl_Operand, 'ZMMREG_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_MZ')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_ER')) or
                    (AnsiSameText(sl_Operand, 'ZMMREG_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMReg;
              Item.OpActive := true;

              //sSuffix := '';
              //if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
              // else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              //
              //if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
              // else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';

              Item.Values.Add('ZMM16');
            end
            else if (AnsiSameText(sl_Operand, 'ZMMRM')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_M')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_MZ')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_ER')) or
                    (AnsiSameText(sl_Operand, 'ZMMRM_SAE'))
                    then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMMRM;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

              //sSuffix := '';
              //if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}'
              // else if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              //
              //if Pos('_ER', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ', {rd-sae}'
              // else if FSAE and (Pos('_SAE', AnsiUppercase(sl_Operand)) > 0) then sSuffix := ', {sae}';

              if x64 then MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values)
               else MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'MEM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM8;
              Item.OpActive := true;



	      if UsePrefix then sl_Prefix := 'byte ';


              sSuffix := '';

	      if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'MEM16') or
                    AnsiSameText(sl_Operand, 'MEM16_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM16;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'word ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_Prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'MEM32') or
                    AnsiSameText(sl_Operand, 'MEM32_M') or
                    AnsiSameText(sl_Operand, 'MEM32_MZ') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'dword ';

              sSuffix := '';

	      if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM64')) or
                    (AnsiSameText(sl_Operand, 'MEM64_M')) or
                    (AnsiSameText(sl_Operand, 'MEM64_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'qword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';

              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM128')) or
                    (AnsiSameText(sl_Operand, 'MEM128_M')) or
                    (AnsiSameText(sl_Operand, 'MEM128_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM128;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';

              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM256')) or
                    (AnsiSameText(sl_Operand, 'MEM256_M')) or
                    (AnsiSameText(sl_Operand, 'MEM256_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM256;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if (AnsiSameText(sl_Operand, 'MEM512')) or
                    (AnsiSameText(sl_Operand, 'MEM512_M')) or
                    (AnsiSameText(sl_Operand, 'MEM512_MZ')) then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otMEM512;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';
              if Pos('_MZ', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1} {z}';


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, sSuffix, FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'REG8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG8;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg8);
              end
              else Item.Values.AddStrings(FReg8);
            end
            else if AnsiSameText(sl_Operand, 'REG16') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG16;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg16);
              end
              else Item.Values.AddStrings(FReg16);
            end
            else if AnsiSameText(sl_Operand, 'REG32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG32;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg32Base);
              end
              else Item.Values.AddStrings(FReg32Base);
            end
            else if AnsiSameText(sl_Operand, 'REG64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otREG64;
              Item.OpActive := true;

              if x64 then
              begin
                Item.Values.AddStrings(FReg64Base);
              end;
            end
            else if AnsiSameText(sl_Operand, 'RM32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM32;
              Item.OpActive := true;

              Item.Values.AddStrings(FReg32Base);

              if UsePrefix then sl_Prefix := 'dword ';

              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'RM64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otRM32;
              Item.OpActive := true;



              if UsePrefix then sl_Prefix := 'qword ';

              if x64 then
              begin
                Item.Values.AddStrings(FReg64Base);
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, '', FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, '', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'IMM8') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otIMM8;
              Item.OpActive := true;

              if FGas then Item.Values.Add('$0') else Item.Values.Add('0');
            end
            else if AnsiSameText(sl_Operand, 'XMEM32') or
                    AnsiSameText(sl_Operand, 'XMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'oword ';

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
		VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false) then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false) then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
              end;
            end
            else if AnsiSameText(sl_Operand, 'XMEM64') or
                    AnsiSameText(sl_Operand, 'XMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otXMEM64;
              Item.OpActive := true;

              //if UsePrefix then sl_Prefix := 'oword ';
              //
              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64XMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32XMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64XMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64XMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32XMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
 		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32XMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'YMEM32') or
                    AnsiSameText(sl_Operand, 'YMEM32_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'YMEM64') or
                    AnsiSameText(sl_Operand, 'YMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otYMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'yword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64YMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32YMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64YMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64YMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32YMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32YMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'ZMEM32') or
                    AnsiSameText(sl_Operand, 'ZMEM32_M')  then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM32;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, 'ZMEM64') or
                    AnsiSameText(sl_Operand, 'ZMEM64_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otZMEM64;
              Item.OpActive := true;

              if UsePrefix then sl_Prefix := 'zword ';

              //if x64 then
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64ZMMIndex, Item.Values);
              //end
              //else
              //begin
              //  VectorMemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32ZMMIndex, Item.Values);
              //end;

              sSuffix := '';
              if Pos('_M', AnsiUppercase(sl_Operand)) > 0 then sSuffix := ' {k1}';

              if x64 then
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg64Base, FReg64ZMMIndex, Item.Values);
		if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
                 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg64Base, FReg64ZMMIndex, Item.Values);
              end
              else
              begin
                VectorMemRegBaseIndexCombi(sl_prefix, sSuffix, FReg32Base, FReg32ZMMIndex, Item.Values);
                if (sSuffix <> '') and
                   (MaskRegNeeded = false)
                        then
		 VectorMemRegBaseIndexCombi(sl_prefix, '', FReg32Base, FReg32ZMMIndex, Item.Values);
              end;

            end
            else if AnsiSameText(sl_Operand, '2B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '4B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '8B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '16B32') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB32;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '2B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to2}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to2}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '4B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to4}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to4}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '8B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to8}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to8}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, '16B64') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otB64;
              Item.OpActive := true;


              if x64 then
              begin
                MemRegBaseIndexCombiCDISP8N(sl_Prefix, ' {1to16}',  FReg64Base, FReg64Index, Item.Values);
                //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values);
              end
              else MemRegBaseIndexCombiCDISP8N(sl_prefix, ' {1to16}', FReg32Base, FReg32Index, Item.Values);
            end
            else if AnsiSameText(sl_Operand, 'KREG') or
                    AnsiSameText(sl_Operand, 'KREG_M') then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otKREG;
              Item.OpActive := true;

              Item.Values.Add('K1');
            end
            else if trim(sl_Operand) = '' then
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('');
            end
            else
            begin
              Item.OpNumber := il_Op;
              Item.OpTyp    := otUnknown;
              Item.OpActive := false;

              Item.Values.Add('?' + sl_Operand);
            end

          end;

          //sl_RegCombi := '';


          il_Operands := 0;
          UsedParams  := 0;

          if OItem1.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 1;
          end;

          if OItem2.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 2;
          end;

          if OItem3.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 4;
          end;

          if OItem4.OpActive then
          begin
            inc(il_Operands);
            UsedParams := UsedParams or 8;
          end;

          case il_Operands of
              1: UseDefault := UsedParams <> 1;
              2: UseDefault := UsedParams <> 3;
              3: UseDefault := UsedParams <> 7;
              4: UseDefault := UsedParams <> 15;
            else UseDefault := true;
          end;

          // TODO deaktivieren
          //UseDefault := true;

          if UseDefault then
          begin
            sl_Inst := format('%-20s', [aInst]);

            for il_Op1 := 0 to OItem1.Values.Count - 1 do
            begin
              for il_Op2 := 0 to OItem2.Values.Count - 1 do
              begin
                for il_Op3 := 0 to OItem3.Values.Count - 1 do
                begin
                  for il_Op4 := 0 to OItem4.Values.Count - 1 do
                  begin
                    slRegCombi := TStringList.Create;
                    try
                      while slRegCombi.Count < 5 do
                       slRegCombi.Add('');


                      //SplitOperands(OItem1.Values[il_Op1], OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]
                      if OItem1.OpActive then
                      begin
                      //  SplitOperand(OItem1.Values[il_Op1], sRegCombi0,sRegCombi1,sRegCombi2,sRegCombi3,sRegCombi4);
                      //
                      end;
                    finally
                      FreeAndNil(slRegCombi);
                    end;

                    //sRegCombi0 := '';
                    //sRegCombi1 := '';
                    //sRegCombi2 := '';
                    //sRegCombi3 := '';
                    //sRegCombi4 := '';
                    //
                    //if OItem1.OpActive then
                    //begin
                    //  if sRegCombi0 <> '' then
                    //  begin
                    //    sRegCombi0 := sRegCombi0 + ', ';
                    //    sRegCombi1 := sRegCombi1 + ', ';
                    //    sRegCombi2 := sRegCombi2 + ', ';
                    //    sRegCombi3 := sRegCombi3 + ', ';
                    //    sRegCombi4 := sRegCombi4 + ', ';
                    //  end;
                    //
                    //  if Pos('|', OItem1.Values[il_Op1]) > 0 then
                    //  begin
                    //    with TStringList.Create do
                    //    try
                    //      Text := Stringreplace(OItem1.Values[il_Op1], '|', #13#10,[rfReplaceAll]);
                    //      iCnt := Count;
                    //      while Count < 5 do Add('');
                    //
                    //      sRegCombi0 := sRegCombi0 + Strings[0];
                    //      sRegCombi1 := sRegCombi1 + Strings[1];
                    //      sRegCombi2 := sRegCombi2 + Strings[2];
                    //      sRegCombi3 := sRegCombi3 + Strings[3];
                    //      sRegCombi4 := sRegCombi4 + Strings[4];
                    //
                    //    finally
                    //      Free;
                    //    end;
                    //  end
                    //  else
                    //  begin
                    //    sRegCombi0 := sRegCombi0 + OItem1.Values[il_Op1];
                    //    sRegCombi1 := sRegCombi1 + OItem1.Values[il_Op1];
                    //    sRegCombi2 := sRegCombi2 + OItem1.Values[il_Op1];
                    //    sRegCombi3 := sRegCombi3 + OItem1.Values[il_Op1];
                    //    sRegCombi4 := sRegCombi4 + OItem1.Values[il_Op1];
                    //  end;
                    //end;
                    //
                    //if OItem2.OpActive then
                    //begin
                    //  if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                    //  sl_RegCombi := sl_RegCombi + OItem2.Values[il_Op2];
                    //end;
                    //
                    //if OItem3.OpActive then
                    //begin
                    //  if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                    //  sl_RegCombi := sl_RegCombi + OItem3.Values[il_Op3];
                    //end;
                    //
                    //if OItem4.OpActive then
                    //begin
                    //  if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', ';
                    //  sl_RegCombi := sl_RegCombi + OItem4.Values[il_Op4];
                    //end;
                    //
                    //if sl_RegCombi <> '' then
                    //begin
                    //  //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
                    //  result.Add(sl_Inst + sl_RegCombi);
                    //  sl_RegCombi := '';
                    //end;
                  end;
                end;
              end;
            end;
          end
          else
          begin
            OpMode := omUnknown;

            iOpNumMRef := -1;
            if (OItem1.OpTyp in MEMTYPES) or
               (OItem1.OpTyp in BMEMTYPES) then iOpNumMRef := 1
             else if (OItem2.OpTyp in MEMTYPES) or
                     (OItem2.OpTyp in BMEMTYPES) then iOpNumMRef := 2
             else if (OItem3.OpTyp in MEMTYPES) or
                     (OItem3.OpTyp in BMEMTYPES) then iOpNumMRef := 3
             else if (OItem4.OpTyp in MEMTYPES) or
                     (OItem4.OpTyp in BMEMTYPES) then iOpNumMRef := 4;


            // TODO delete
            //if il_Operands = 4 then

            case il_Operands of
                2: begin
                     if (OItem1.OpTyp in MEMTYPES) and
                        (OItem2.OpTyp = otXMMReg) then OpMode := omMX
                      else if (OItem1.OpTyp in MEMTYPES) and
                              (OItem2.OpTyp = otYMMReg) then OpMode := omMY
                      else if (OItem1.OpTyp in MEMTYPES) and
                              (OItem2.OpTyp = otZMMReg) then OpMode := omMZ

                      else if (OItem1.OpTyp = otXMMReg) and
                              (OItem2.OpTyp = otB32) then OpMode := omXB32
                      else if (OItem1.OpTyp = otXMMReg) and
                              (OItem2.OpTyp = otB64) then OpMode := omXB64

                      else if (OItem1.OpTyp = otYMMReg) and
                              (OItem2.OpTyp = otB32) then OpMode := omYB32
                      else if (OItem1.OpTyp = otYMMReg) and
                              (OItem2.OpTyp = otB64) then OpMode := omYB64

                      else if (OItem1.OpTyp = otZMMReg) and
                              (OItem2.OpTyp = otB32) then OpMode := omZB32
                      else if (OItem1.OpTyp = otZMMReg) and
                              (OItem2.OpTyp = otB64) then OpMode := omZB64

                      else if (OItem1.OpTyp = otXMMReg) and
                              (OItem2.OpTyp in MEMTYPES) then OpMode := omXM
                      else if (OItem1.OpTyp = otYMMReg) and
                              (OItem2.OpTyp in MEMTYPES) then OpMode := omYM
                      else if (OItem1.OpTyp = otZMMReg) and
                              (OItem2.OpTyp in MEMTYPES) then OpMode := omZM




                     else
                     begin
                       sLogMsg := '';
                       sLogMsg := MapOperand(OItem1.Optyp) + MapOperand(OItem2.Optyp) + MapOperand(OItem3.Optyp);
                       if sLogMsg <> '' then
                       begin

                         if (sLogMsg <> 'KX') and
                            (sLogMsg <> 'KY') and
                            (sLogMsg <> 'KZ') and
                            (sLogMsg <> 'RM') and
                            (sLogMsg <> 'RX') and
                            (sLogMsg <> 'XK') and
                            (sLogMsg <> 'XR') and
                            (sLogMsg <> 'XX') and
                            (sLogMsg <> 'XY') and
                            (sLogMsg <> 'XZ') and
                            (sLogMsg <> 'YK') and
                            (sLogMsg <> 'YR') and
                            (sLogMsg <> 'YX') and
                            (sLogMsg <> 'YY') and
                            (sLogMsg <> 'YZ') and
                            (sLogMsg <> 'ZK') and
                            (sLogMsg <> 'ZR') and
                            (sLogMsg <> 'ZX') and
                            (sLogMsg <> 'ZY') and
                            (sLogMsg <> 'ZZ') then

                         writeln('offen : ' + sLogMsg + ' (' + aInst + ')');
                       end;
                     end;
                   end;
                3: if (OItem1.OpTyp = otKReg) and
                      (OItem2.OpTyp = otXMMReg) and
                      (OItem3.OpTyp in MEMTYPES) then OpMode := omKXM
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp in MEMTYPES) then OpMode := omKYM
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp in MEMTYPES) then OpMode := omKZM

                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otXMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omKXB32
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otXMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omKXB64
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omKYB32
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omKYB64
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omKZB32
                    else if (OItem1.OpTyp = otKReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omKZB64

                    else if (OItem1.OpTyp = otKReg)    and
                            (OItem2.OpTyp in MEMTYPES) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omKMI
                    else if (OItem1.OpTyp = otKReg)    and
                            (OItem2.OpTyp = otB32)     and
                            (OItem3.OpTyp = otIMM8) then OpMode := omKB32I
                    else if (OItem1.OpTyp = otKReg)    and
                            (OItem2.OpTyp = otB64)     and
                            (OItem3.OpTyp = otIMM8) then OpMode := omKB64I

                    else if (OItem1.OpTyp in MEMTYPES) and
                            (OItem2.OpTyp = otXMMReg)  and
                            (OItem3.OpTyp = otIMM8) then OpMode := omMXI
                    else if (OItem1.OpTyp in MEMTYPES) and
                            (OItem2.OpTyp = otYMMReg)  and
                            (OItem3.OpTyp = otIMM8) then OpMode := omMYI
                    else if (OItem1.OpTyp in MEMTYPES) and
                            (OItem2.OpTyp = otZMMReg)  and
                            (OItem3.OpTyp = otIMM8) then OpMode := omMZI

                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp = otXMMReg) and
                            (OItem3.OpTyp in MEMTYPES) then OpMode := omXXM
                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp = otXMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omXXB32
                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp = otXMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omXXB64
                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp = otB32) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omXB32I
                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp = otB64) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omXB64I
                    else if (OItem1.OpTyp = otXMMReg) and
                            (OItem2.OpTyp in MEMTYPES) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omXMI

                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp in MEMTYPES) then OpMode := omYYM
                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omYYB32
                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp = otYMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omYYB64
                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp = otB32) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omYB32I
                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp = otB64) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omYB64I
                    else if (OItem1.OpTyp = otYMMReg) and
                            (OItem2.OpTyp in MEMTYPES) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omYMI

                    else if (OItem1.OpTyp = otZMMReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp in MEMTYPES) then OpMode  := omZZM
                    else if (OItem1.OpTyp = otZMMReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp = otB32) then OpMode := omZZB32
                    else if (OItem1.OpTyp = otZMMReg) and
                            (OItem2.OpTyp = otZMMReg) and
                            (OItem3.OpTyp = otB64) then OpMode := omZZB64
                            else if (OItem1.OpTyp = otZMMReg) and
                                    (OItem2.OpTyp = otB32) and
                                    (OItem3.OpTyp = otIMM8) then OpMode := omZB32I
                            else if (OItem1.OpTyp = otZMMReg) and
                                    (OItem2.OpTyp = otB64) and
                                    (OItem3.OpTyp = otIMM8) then OpMode := omZB64I
                    else if (OItem1.OpTyp = otZMMReg) and
                            (OItem2.OpTyp in MEMTYPES) and
                            (OItem3.OpTyp = otIMM8) then OpMode := omZMI


                    else
                    begin
                      sLogMsg := '';
                      sLogMsg := MapOperand(OItem1.Optyp) + MapOperand(OItem2.Optyp) + MapOperand(OItem3.Optyp);
                      if sLogMsg <> '' then
                      begin
                       if (sLogMsg <> 'RMI') and
                          (sLogMsg <> 'RRM') and
                          (sLogMsg <> 'RMR') and
                          (sLogMsg <> 'KKK') and
                          (sLogMsg <> 'KKI') and
                          (sLogMsg <> 'XXX') and
                          (sLogMsg <> 'YYY') and
                          (sLogMsg <> 'ZZZ') and
                          (sLogMsg <> 'XXI') and
                          (sLogMsg <> 'YYI') and
                          (sLogMsg <> 'ZZI') and
                          (sLogMsg <> 'XYI') and
                          (sLogMsg <> 'YZI') and
                          (sLogMsg <> 'XZI') and
                          (sLogMsg <> 'RXI') and
                          (sLogMsg <> 'RYI') and
                          (sLogMsg <> 'RZI') and


                          (sLogMsg <> 'XXR') then

                       writeln('offen : ' + sLogMsg + ' (' + aInst + ')');
                      end;
                    end;
                 4: if (OItem1.OpTyp = otKReg)       and
                       (OItem2.OpTyp = otXMMReg)     and
                       (OItem3.OpTyp = otB32)        and
                       (OItem4.OpTyp = otIMM8) then OpMode := omKXB32I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otXMMReg)     and
                             (OItem3.OpTyp = otB64)        and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKXB64I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otXMMReg)     and
                             (OItem3.OpTyp in MEMTYPES)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKXMI

                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otYMMReg)     and
                             (OItem3.OpTyp = otB32)        and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKYB32I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otYMMReg)     and
                             (OItem3.OpTyp = otB64)        and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKYB64I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otYMMReg)     and
                             (OItem3.OpTyp in MEMTYPES)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKYMI

                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otZMMReg)     and
                             (OItem3.OpTyp = otB32)        and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKZB32I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otZMMReg)     and
                             (OItem3.OpTyp = otB64)        and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKZB64I
                     else if (OItem1.OpTyp = otKReg)       and
                             (OItem2.OpTyp = otZMMReg)     and
                             (OItem3.OpTyp in MEMTYPES)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omKZMI

                     else if (OItem1.OpTyp = otXMMReg) and
                             (OItem2.OpTyp = otXMMReg) and
                             (OItem3.OpTyp = otB32)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omXXB32I
                     else if (OItem1.OpTyp = otXMMReg) and
                             (OItem2.OpTyp = otXMMReg) and
                             (OItem3.OpTyp = otB64)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omXXB64I
                     else if (OItem1.OpTyp = otYMMReg) and
                             (OItem2.OpTyp = otYMMReg) and
                             (OItem3.OpTyp = otB32)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omYYB32I
                     else if (OItem1.OpTyp = otYMMReg) and
                             (OItem2.OpTyp = otYMMReg) and
                             (OItem3.OpTyp = otB64)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omYYB64I
                     else if (OItem1.OpTyp = otZMMReg) and
                             (OItem2.OpTyp = otZMMReg) and
                             (OItem3.OpTyp = otB32)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omZZB32I
                     else if (OItem1.OpTyp = otZMMReg) and
                             (OItem2.OpTyp = otZMMReg) and
                             (OItem3.OpTyp = otB64)    and
                             (OItem4.OpTyp = otIMM8) then OpMode := omZZB64I


                     else if (OItem1.OpTyp = otXMMReg) and
                             (OItem2.OpTyp = otXMMReg) and
                             (OItem3.OpTyp in MEMTYPES) and
                             (OItem4.OpTyp = otIMM8) then OpMode := omXXMI
                     else if (OItem1.OpTyp = otYMMReg) and
                             (OItem2.OpTyp = otYMMReg) and
                             (OItem3.OpTyp in MEMTYPES) and
                             (OItem4.OpTyp = otIMM8) then OpMode := omYYMI
                     else if (OItem1.OpTyp = otZMMReg) and
                             (OItem2.OpTyp = otZMMReg) and
                             (OItem3.OpTyp in MEMTYPES) and
                             (OItem4.OpTyp = otIMM8) then OpMode := omZZMI
                     else
                     begin
                       sLogMsg := '';
                       sLogMsg := MapOperand(OItem1.Optyp) + MapOperand(OItem2.Optyp) + MapOperand(OItem3.Optyp) + MapOperand(OItem4.Optyp);
                       if sLogMsg <> '' then
                       begin

                         if (sLogMsg <> 'KXXI') and
                            (sLogMsg <> 'KYYI') and
                            (sLogMsg <> 'KZZI') and
                            (sLogMsg <> 'XXRI') and
                            (sLogMsg <> 'XXXI') and
                            (sLogMsg <> 'YYYI') and
                            (sLogMsg <> 'ZZZI') then

                         writeln('offen : ' + sLogMsg + ' (' + aInst + ')');
                       end;
                     end;

              else;
            end;

            if OpMode <> omUnknown then
            begin
              sInstruction := format('%20s', [aInst]);

              for il_Op1 := 0 to OItem1.Values.Count - 1 do
              begin
                for il_Op2 := 0 to OItem2.Values.Count - 1 do
                begin
                  for il_Op3 := 0 to OItem3.Values.Count - 1 do
                  begin
                    for il_Op4 := 0 to OItem4.Values.Count - 1 do
                    begin
                      sRegCombi := '';

                      if OItem1.OpActive then
                      begin
                        if sRegCombi <> '' then sRegCombi := sRegCombi + ', ';
                        sRegCombi := sRegCombi + OItem1.Values[il_Op1];
                      end;

                      if OItem2.OpActive then
                      begin
                        if sRegCombi <> '' then sRegCombi := sRegCombi + ', ';
                        sRegCombi := sRegCombi + OItem2.Values[il_Op2];
                      end;

                      if OItem3.OpActive then
                      begin
                        if sRegCombi <> '' then sRegCombi := sRegCombi + ', ';
                        sRegCombi := sRegCombi + OItem3.Values[il_Op3];
                      end;

                      if OItem4.OpActive then
                      begin
                        if sRegCombi <> '' then sRegCombi := sRegCombi + ', ';
                        sRegCombi := sRegCombi + OItem4.Values[il_Op4];
                      end;

                      if sRegCombi <> '' then
                      begin
                        case iOpNumMRef of
                            1: sMRef := OItem1.Values[il_Op1];
                            2: sMRef := OItem2.Values[il_Op2];
                            3: sMRef := OItem3.Values[il_Op3];
                            4: sMRef := OItem1.Values[il_Op4];
                          else sMRef := '';
                        end;

                        if ParseBaseIndexReg(sMRef, sBaseReg, sIndexReg) then
                        begin
                          result.Add(format('%20s %s',               ['    pop', sBaseReg]));
                          result.Add(format('%20s %s',               ['   push', sBaseReg]));

                          if trim(sIndexReg) <> '' then
                           result.Add(format('%20s%6s, %s',          ['   xor', sIndexReg, sIndexReg]));

                          if OpMode in [omMXI, omMYI, omMZI] then
                          begin
                            case Fx64 of
                              true: begin
                                      result.Add(format('%20s %6s', ['push', 'RDI']));
                                      result.Add(format('%20s %6s', ['push', 'RCX']));
                                      result.Add(format('%20s %6s', ['push', 'RAX']));

                                      result.Add(format('%20s %6s', ['push', sBaseReg]));
                                      result.Add(format('%20s %6s', ['pop',  'RDI']));
                                      result.Add(format('%20s %6s', ['mov',  'RCX, sizeof(DataBlock)']));
                                      result.Add(format('%20s %6s, %s', ['xor',  'RAX', 'RAX']));
                                      result.Add(format('%20s ',    ['rep stosb']));
                                      result.Add(format('%20s %6s', ['pop',  'RAX']));
                                      result.Add(format('%20s %6s', ['pop',  'RCX']));
                                      result.Add(format('%20s %6s', ['pop',  'RDI']));
                                    end;
                               else begin
                                      result.Add(format('%20s %6s', ['push', 'EDI']));
                                      result.Add(format('%20s %6s', ['push', 'ECX']));
                                      result.Add(format('%20s %6s', ['push', 'EAX']));

                                      result.Add(format('%20s %6s', ['push', sBaseReg]));
                                      result.Add(format('%20s %6s', ['pop',  'EDI']));
                                      result.Add(format('%20s %6s', ['mov',  'ECX, sizeof(DataBlock)']));
                                      result.Add(format('%20s %6s, %s', ['xor',  'EAX', 'EAX']));
                                      result.Add(format('%20s ',    ['rep stosb']));
                                      result.Add(format('%20s %6s', ['pop',  'EAX']));
                                      result.Add(format('%20s %6s', ['pop',  'ECX']));
                                      result.Add(format('%20s %6s', ['pop',  'EDI']));
                                    end;
                            end;
                          end;

                        end;


                        //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
                        result.Add(format('%-20s %6s', [sInstruction, sRegCombi]));

                        inc(iAsmCounter);
                        case OpMode of
                            omKXM,
                            omKYM,
                            omKZM: begin
                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;
                          omKXB32,
                          omKXB64,
                          omKYB32,
                          omKYB64,
                          omKZB32,
                          omKZB64: begin
                                     sMREF := OItem3.Values[il_Op3];
                                     //if Pos('{1to4}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to4}', '{1to2}', [])
                                     // else if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to4}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to8}', []);

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'K2', OItem2.Values[il_Op2], sMREF]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;
                            omKMI: begin
                                     result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;
                            omKB32I,
                            omKB64I:
                                   begin
                                     result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;

                             omMX: begin
                                     result.Add(format('%20s %6s + $2000, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2]]));
                                     result.Add(format('%20s %6s, %s',         ['vmovdqu', 'xmm0', OItem1.Values[il_Op1]]));
                                     result.Add(format('%20s %6s, %s + $2000', ['vmovdqu', 'xmm1', OItem1.Values[il_Op1]]));

                                     result.Add(format('%20s %6s, %6s, %s',    ['vpcmpeqw', 'K2', 'XMM0', 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omMXI: begin
                                     result.Add(format('%20s %6s + $2000, %6s, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s, %s',              ['vmovdqu', 'xmm0', OItem1.Values[il_Op1]]));
                                     result.Add(format('%20s %6s, %s + $2000',      ['vmovdqu', 'xmm1', OItem1.Values[il_Op1]]));

                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqw', 'K2', 'XMM0', 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                             omMY: begin
                                     result.Add(format('%20s %6s + $2000, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2]]));
                                     result.Add(format('%20s %6s, %s',         ['vmovdqu', 'ymm0', OItem1.Values[il_Op1]]));
                                     result.Add(format('%20s %6s, %s + $2000', ['vmovdqu', 'ymm1', OItem1.Values[il_Op1]]));

                                     result.Add(format('%20s %6s, %6s, %s',    ['vpcmpeqd', 'K2', 'YMM0', 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                            omMYI: begin
                                     result.Add(format('%20s %6s + $2000, %6s, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s, %s',              ['vmovdqu', 'ymm0', OItem1.Values[il_Op1]]));
                                     result.Add(format('%20s %6s, %s + $2000',      ['vmovdqu', 'ymm1', OItem1.Values[il_Op1]]));

                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqd', 'K2', 'YMM0', 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omMZ: begin
                                    result.Add(format('%20s %6s + $2000, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2]]));
                                    result.Add(format('%20s %6s, %s',         ['vmovdqu8', 'zmm0', OItem1.Values[il_Op1]]));
                                    result.Add(format('%20s %6s, %s + $2000', ['vmovdqu8', 'zmm1', OItem1.Values[il_Op1]]));

                                    result.Add(format('%20s %6s, %6s, %s',    ['vpcmpeqq', 'K2', 'ZMM0', 'ZMM1']));

                                    result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                  end;

                            omMZI: begin
                                     result.Add(format('%20s %6s + $2000, %6s, %s', [aInst, OItem1.Values[il_Op1], OItem2.Values[il_Op2], OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s, %s',              ['vmovdqu8', 'zmm0', OItem1.Values[il_Op1]]));
                                     result.Add(format('%20s %6s, %s + $2000',      ['vmovdqu8', 'zmm1', OItem1.Values[il_Op1]]));

                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqq', 'K2', 'ZMM0', 'ZMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                           omXB32,
                           omXB64: begin
                                     sMREF := OItem2.Values[il_Op2];
                                     result.Add(format('%20s%6s,%6s + $2000', [aInst, 'XMM1', sMREF]));
                                     result.Add(format('%20s%6s,%6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;


                          omXB32I,
                          omXB64I: begin
                                     sMREF := OItem2.Values[il_Op2];
                                     //if Pos('{1to4}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to4}', '{1to2}', [])
                                     // else if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to4}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to8}', []);

                                     result.Add(format('%20s%6s,%6s + $2000, %s', [aInst, 'XMM1', sMREF, OItem3.Values[il_Op3]]));
                                     result.Add(format('%20s%6s,%6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                             omXM: begin
                                     result.Add(format('%20s %6s, %s + $2000', [aInst, 'XMM1', OItem2.Values[il_Op2] ]));
                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                            omXXM: begin

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'XMM1', 'XMM1', OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                          omXXB32,
                          omXXB64: begin
                                     sMREF := OItem3.Values[il_Op3];
                                     //if Pos('{1to4}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to4}', '{1to2}', [])
                                     // else if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to4}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to8}', []);

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'XMM1', 'XMM1', sMREF]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                            omXMI: begin
                                     result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'XMM1', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     result.Add(format('%20s %6s,%6s, %s',       ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omYB32,
                            omYB64: begin
                                      sMREF := OItem2.Values[il_Op2];
                                      result.Add(format('%20s%6s,%6s + $2000', [aInst, 'YMM1', sMREF]));
                                      result.Add(format('%20s%6s,%6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                      result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                    end;
                            omYB32I,
                            omYB64I:
                                   begin
                                     sMREF := OItem2.Values[il_Op2];
                                     //if Pos('{1to4}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to4}', '{1to2}', [])
                                     // else if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to4}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to8}', []);

                                     //result.Add(format('%20s%6s,%6s + $00, %s', [aInst, 'XMM1', sMREF, OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s + $10, %s', [aInst, 'XMM2', sMREF, OItem3.Values[il_Op3]]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'YMM1', 'YMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'YMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');
                                     result.Add(format('%20s%6s,%6s + $2000, %s', [aInst, 'YMM1', sMREF, OItem3.Values[il_Op3]]));
                                     result.Add(format('%20s%6s,%6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                             omYM: begin
                                     result.Add(format('%20s %6s, %s + $2000', [aInst, 'YMM1', OItem2.Values[il_Op2] ]));
                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omYYM: begin
                                     //result.Add(format('%20s%6s,%6s, %s + $00', [aInst, 'XMM1', 'XMM1', OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s, %s + $10', [aInst, 'XMM2', 'XMM2', OItem3.Values[il_Op3]]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'YMM1', 'YMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'YMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'YMM1', 'YMM1', OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                          omYYB32,
                          omYYB64: begin
                                     sMREF := OItem3.Values[il_Op3];
                                     //if Pos('{1to4}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to4}', '{1to2}', [])
                                     // else if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to4}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to8}', []);

                                     //result.Add(format('%20s%6s,%6s, %s + $00', [aInst, 'XMM1', 'XMM1', sMREF]));
                                     //result.Add(format('%20s%6s,%6s, %s + $10', [aInst, 'XMM2', 'XMM2', sMREF]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'YMM1', 'YMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'YMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');
                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'YMM1', 'YMM1', sMREF]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));

                                   end;
                            omYMI: begin
                                     //result.Add(format('%20s%6s,%6s + $00, %s', [aInst, 'XMM1', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s + $10, %s', [aInst, 'XMM2', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'YMM1', 'YMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'YMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');
                                     result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'YMM1', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     result.Add(format('%20s %6s,%6s, %s',       ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omZB32,
                            omZB64: begin
                                      sMREF := OItem2.Values[il_Op2];
                                      result.Add(format('%20s%6s,%6s + $2000', [aInst, 'ZMM1', sMREF]));
                                      result.Add(format('%20s%6s,%6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                      result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                    end;
                            omZB32I,
                            omZB64I:
                                    begin
                                      sMREF := OItem2.Values[il_Op2];
                                       //if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to2}', [])
                                       // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to4}', []);

                                       //result.Add(format('%20s%6s,%6s + $00, %s', [aInst, 'XMM1', sMREF, OItem3.Values[il_Op3]]));
                                       //result.Add(format('%20s%6s,%6s + $10, %s', [aInst, 'XMM2', sMREF, OItem3.Values[il_Op3]]));
                                       //result.Add(format('%20s%6s,%6s + $20, %s', [aInst, 'XMM3', sMREF, OItem3.Values[il_Op3]]));
                                       //
                                       //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM2']));
                                       //result.Add(format('%20s%6s,%6s, %s, 02',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM3']));
                                       //result.Add(format('%20s%6s,%6s, %s, 03',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM4']));
                                       //
                                       //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'ZMM1']));
                                       //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                       //result.Add('');

                                       result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'ZMM1', sMREF, OItem3.Values[il_Op3]]));
                                       result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                       result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));

                                     end;
                             omZM: begin
                                     result.Add(format('%20s %6s, %s + $2000', [aInst, 'ZMM1', OItem2.Values[il_Op2] ]));
                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                            omZZM: begin
                                     //result.Add(format('%20s%6s,%6s, %s + $00', [aInst, 'XMM1', 'XMM1', OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s, %s + $10', [aInst, 'XMM2', 'XMM2', OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s, %s + $20', [aInst, 'XMM3', 'XMM3', OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s, %s + $30', [aInst, 'XMM4', 'XMM4', OItem3.Values[il_Op3]]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s, 02',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM3']));
                                     //result.Add(format('%20s%6s,%6s, %s, 03',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM4']));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'ZMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'ZMM1', 'ZMM1', OItem3.Values[il_Op3] ]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                          omZZB32,
                          omZZB64: begin
                                     sMREF := OItem3.Values[il_Op3];
                                     //if Pos('{1to8}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to8}', '{1to2}', [])
                                     // else if Pos('{1to16}', sMREF) > 0 then sMREF := StringReplace(sMREF, '{1to16}', '{1to4}', []);

                                     //result.Add(format('%20s%6s,%6s, %s + $00', [aInst, 'XMM1', 'XMM1', sMREF]));
                                     //result.Add(format('%20s%6s,%6s, %s + $10', [aInst, 'XMM2', 'XMM2', sMREF]));
                                     //result.Add(format('%20s%6s,%6s, %s + $20', [aInst, 'XMM3', 'XMM3', sMREF]));
                                     //result.Add(format('%20s%6s,%6s, %s + $30', [aInst, 'XMM4', 'XMM4', sMREF]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s, 02',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM3']));
                                     //result.Add(format('%20s%6s,%6s, %s, 03',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM4']));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'ZMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');

                                     result.Add(format('%20s %6s,%6s, %s + $2000', [aInst, 'ZMM1', 'ZMM1', sMREF]));
                                     result.Add(format('%20s %6s,%6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));

                                   end;
                            omZMI: begin
                                     //result.Add(format('%20s%6s,%6s + $00, %s', [aInst, 'XMM1', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s + $10, %s', [aInst, 'XMM2', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s + $20, %s', [aInst, 'XMM3', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //result.Add(format('%20s%6s,%6s + $30, %s', [aInst, 'XMM4', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s, 01',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM2']));
                                     //result.Add(format('%20s%6s,%6s, %s, 02',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM3']));
                                     //result.Add(format('%20s%6s,%6s, %s, 03',   ['vinserti32x4', 'ZMM1', 'ZMM1', 'XMM4']));
                                     //
                                     //result.Add(format('%20s%6s,%6s, %s',       ['vpcmpeqb', 'K2', OItem1.Values[il_Op1], 'ZMM1']));
                                     //result.Add(format('%20s%6s,%6s, %s',       ['kandq', 'K1', 'K1', 'K2']));
                                     //result.Add('');
                                     result.Add(format('%20s %6s,%6s + $2000, %s', [aInst, 'ZMM1', OItem2.Values[il_Op2], OItem3.Values[il_Op3]]));
                                     result.Add(format('%20s %6s,%6s, %s',       ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;

                            omKXB32I,
                            omKXB64I:
                                   begin
                                     result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]]));
                                     result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;
                             omKXMI:
                                   begin
                                     result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]]));
                                     result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                   end;
                           omKYB32I,
                           omKYB64I:
                                 begin
                                   result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]]));
                                   result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                   result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                 end;
                             omKYMI:
                                 begin
                                   result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]]));
                                   result.Add(format('%20s %6s,%6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                   result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                 end;

                            omXXB32I,
                            omXXB64I:
                                   begin
                                     sMREF := OItem3.Values[il_Op3];

                                     result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'XMM1', OItem2.Values[il_Op2], sMREF, OItem4.Values[il_Op4]]));
                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                             omXXMI:
                                   begin
                                     sMREF := OItem3.Values[il_Op3];

                                     result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'XMM1', OItem2.Values[il_Op2], sMREF, OItem4.Values[il_Op4]]));
                                     result.Add(format('%20s %6s, %6s, %s',              ['vpcmpeqw', 'K2', OItem1.Values[il_Op1], 'XMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                             omYYB32I,
                             omYYB64I,
                               omYYMI:
                                   begin
                                     sMREF := OItem3.Values[il_Op3];

                                     result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'YMM1', OItem2.Values[il_Op2], sMREF, OItem4.Values[il_Op4]]));
                                     result.Add(format('%20s %6s, %6s, %s',         ['vpcmpeqd', 'K2', OItem1.Values[il_Op1], 'YMM1']));

                                     result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                   end;
                            omKZB32I,
                            omKZB64I,
                              omKZMI:
                                  begin
                                    result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'K2', OItem2.Values[il_Op2], OItem3.Values[il_Op3], OItem4.Values[il_Op4]]));
                                    result.Add(format('%20s %6s, %6s, %s', ['kxorq', 'K2', OItem1.Values[il_Op1], 'K2']));

                                    result.Add(AsmCodeBlockCompare(iAsmCounter, cmXORTestNZ));
                                  end;
                            //omKZMI:
                            //      begin
                            //        sMREF := OItem3.Values[il_Op3];
                            //
                            //        result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'ZMM1', OItem2.Values[il_Op2], sMREF, OItem4.Values[il_Op4]]));
                            //        result.Add(format('%20s %6s, %6s, %6s, %s',         ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));
                            //
                            //        result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                            //      end;

                            omZZB32I,
                            omZZB64I,
                              omZZMI:
                                  begin
                                    sMREF := OItem3.Values[il_Op3];

                                    result.Add(format('%20s %6s, %6s, %6s + $2000, %s', [aInst, 'ZMM1', OItem2.Values[il_Op2], sMREF, OItem4.Values[il_Op4]]));
                                    result.Add(format('%20s %6s, %6s, %s',              ['vpcmpeqq', 'K2', OItem1.Values[il_Op1], 'ZMM1']));

                                    result.Add(AsmCodeBlockCompare(iAsmCounter, cmKORTESTNC));
                                  end;
                             else begin
                                    sLogMsg := '';
                                    sLogMsg := MapOperand(OItem1.Optyp) + MapOperand(OItem2.Optyp) + MapOperand(OItem3.Optyp);
                                    writeln('offen - : ' + sLogMsg + ' (' + aInst + ')');
                                  end;
                        end;

                        sRegCombi := '';
                      end;
                    end;
                  end;
                end;
              end;
            end;



            //sl_Inst := format('%-20s', [aInst]);
            //
            //for il_Op1 := 0 to OItem1.Values.Count - 1 do
            //begin
            //  if OItem1.OpActive then
            //  begin
            //    sl_RegCombi1 := OItem1.Values[il_Op1];
            //  end
            //  else sl_RegCombi1 := '';
            //
            //  for il_Op2 := 0 to OItem2.Values.Count - 1 do
            //  begin
            //    if OItem2.OpActive then
            //    begin
            //      sl_RegCombi2 := sl_RegCombi1 + ', ' + OItem2.Values[il_Op2];
            //    end
            //    else sl_RegCombi2 := sl_RegCombi1;
            //
            //    for il_Op3 := 0 to OItem3.Values.Count - 1 do
            //    begin
            //      if OItem3.OpActive then
            //      begin
            //        sl_RegCombi3 := sl_RegCombi2 + ', ' + OItem3.Values[il_Op3];
            //      end
            //      else sl_RegCombi3 := sl_RegCombi2;
            //
            //      for il_Op4 := 0 to OItem4.Values.Count - 1 do
            //      begin
            //        if OItem4.OpActive then
            //        begin
            //          sl_RegCombi := sl_RegCombi3 + ', ' + OItem4.Values[il_Op4];
            //        end
            //        else sl_RegCombi := sl_RegCombi3;
            //
            //        if (sl_RegCombi <> '') and
            //           (
            //            (OItem1.OpActive and (OItem1.OpTyp in OTMEMTYPES)) or
            //            (OItem2.OpActive and (OItem2.OpTyp in OTMEMTYPES)) or
            //            (OItem3.OpActive and (OItem3.OpTyp in OTMEMTYPES)) or
            //            (OItem4.OpActive and (OItem4.OpTyp in OTMEMTYPES))
            //           ) then
            //        begin
            //          //result.Add(format('%-20s%s', [aInst, sl_RegCombi]));
            //          result.Add(sl_Inst + sl_RegCombi);
            //
            //
            //
            //          sl_RegCombi := '';
            //        end;
            //      end;
            //    end;
            //  end;
            //end;
          end;
        finally
          FreeAndNil(OItem4);
        end;
      finally
        FreeAndNil(OItem3);
      end;
    finally
      FreeAndNil(OItem2);
    end;
  finally
    FreeAndNil(OItem1);
  end;
end;


constructor TAsmTestGenerator.Create(aGas:boolean);
begin
  inherited Create();

  FX64 := true;
  FAVX512 := false;
  FGas := aGas;

  FReg8          := TStringList.Create;
  FReg16         := TStringList.Create;

  FReg32Base     := TStringList.Create;
  FReg32Index    := TStringList.Create;
  FReg64Base     := TStringList.Create;
  FReg64Index    := TStringList.Create;
  FReg6432Base   := TStringList.Create;
  FReg6432Index  := TStringList.Create;
  FReg32XMMIndex := TStringList.Create;
  FReg32YMMIndex := TStringList.Create;
  FReg32ZMMIndex := TStringList.Create;
  FReg64XMMIndex := TStringList.Create;
  FReg64YMMIndex := TStringList.Create;
  FReg64ZMMIndex := TStringList.Create;
  FRegKREG       := TStringList.Create;


  FReg8.Add('AL');
  FReg8.Add('BL');
  FReg8.Add('CL');
  FReg8.Add('DL');


  FReg16.Add('AX');
  FReg16.Add('BX');
  FReg16.Add('CX');
  FReg16.Add('DX');


  FReg32Base.Add('EAX');
  FReg32Base.Add('EBX');
  FReg32Base.Add('ECX');
  FReg32Base.Add('EDX');
  //FReg32Base.Add('ESP');
  //FReg32Base.Add('EBP');
  FReg32Base.Add('EDI');
  FReg32Base.Add('ESI');


  FReg32Index.Add('EAX');
  FReg32Index.Add('EBX');
  FReg32Index.Add('ECX');
  FReg32Index.Add('EDX');
  FReg32Index.Add('EBP');
  FReg32Index.Add('EDI');
  FReg32Index.Add('ESI');


  FReg64Base.Add('RAX');
  FReg64Base.Add('RBX');
  FReg64Base.Add('RCX');
  FReg64Base.Add('RDX');
  //FReg64Base.Add('RSP');
  //FReg64Base.Add('RBP');
  FReg64Base.Add('RDI');
  FReg64Base.Add('RSI');
  FReg64Base.Add('R8');
  FReg64Base.Add('R9');
  FReg64Base.Add('R10');
  FReg64Base.Add('R11');
  FReg64Base.Add('R12');
  //FReg64Base.Add('R13');
  FReg64Base.Add('R14');
  FReg64Base.Add('R15');

  FReg64Index.Add('RAX');
  FReg64Index.Add('RBX');
  FReg64Index.Add('RCX');
  FReg64Index.Add('RDX');
  FReg64Index.Add('RBP');
  FReg64Index.Add('RDI');
  FReg64Index.Add('RSI');
  FReg64Index.Add('R8');
  FReg64Index.Add('R9');
  FReg64Index.Add('R10');
  FReg64Index.Add('R11');
  FReg64Index.Add('R12');
  FReg64Index.Add('R13');
  FReg64Index.Add('R14');
  FReg64Index.Add('R15');

  FReg6432Base.Add('EAX');
  FReg6432Base.Add('EBX');
  FReg6432Base.Add('ECX');
  FReg6432Base.Add('EDX');
  FReg6432Base.Add('ESP');
  //FReg6432Base.Add('EBP');
  FReg6432Base.Add('EDI');
  FReg6432Base.Add('ESI');
  FReg6432Base.Add('R8D');
  FReg6432Base.Add('R9D');
  FReg6432Base.Add('R10D');
  FReg6432Base.Add('R11D');
  FReg6432Base.Add('R12D');
  //FReg6432Base.Add('R13D');
  FReg6432Base.Add('R14D');
  FReg6432Base.Add('R15D');

  FReg6432Index.Add('EAX');
  FReg6432Index.Add('EBX');
  FReg6432Index.Add('ECX');
  FReg6432Index.Add('EDX');
  FReg6432Index.Add('EBP');
  FReg6432Index.Add('EDI');
  FReg6432Index.Add('ESI');
  FReg6432Index.Add('R8D');
  FReg6432Index.Add('R9D');
  FReg6432Index.Add('R10D');
  FReg6432Index.Add('R11D');
  FReg6432Index.Add('R12D');
  FReg6432Index.Add('R13D');
  FReg6432Index.Add('R14D');
  FReg6432Index.Add('R15D');

  FReg32XMMIndex.ADD('XMM0');
  FReg32XMMIndex.ADD('XMM1');
  FReg32XMMIndex.ADD('XMM2');
  FReg32XMMIndex.ADD('XMM3');
  FReg32XMMIndex.ADD('XMM4');
  FReg32XMMIndex.ADD('XMM5');
  FReg32XMMIndex.ADD('XMM6');
  FReg32XMMIndex.ADD('XMM7');

  FReg32YMMIndex.ADD('YMM0');
  FReg32YMMIndex.ADD('YMM1');
  FReg32YMMIndex.ADD('YMM2');
  FReg32YMMIndex.ADD('YMM3');
  FReg32YMMIndex.ADD('YMM4');
  FReg32YMMIndex.ADD('YMM5');
  FReg32YMMIndex.ADD('YMM6');
  FReg32YMMIndex.ADD('YMM7');

  FReg32ZMMIndex.ADD('ZMM0');
  FReg32ZMMIndex.ADD('ZMM1');
  FReg32ZMMIndex.ADD('ZMM2');
  FReg32ZMMIndex.ADD('ZMM3');
  FReg32ZMMIndex.ADD('ZMM4');
  FReg32ZMMIndex.ADD('ZMM5');
  FReg32ZMMIndex.ADD('ZMM6');
  FReg32ZMMIndex.ADD('ZMM7');


  FReg64XMMIndex.ADD('XMM0');
  FReg64XMMIndex.ADD('XMM1');
  FReg64XMMIndex.ADD('XMM2');
  FReg64XMMIndex.ADD('XMM3');
  FReg64XMMIndex.ADD('XMM4');
  FReg64XMMIndex.ADD('XMM5');
  FReg64XMMIndex.ADD('XMM6');
  FReg64XMMIndex.ADD('XMM7');
  FReg64XMMIndex.ADD('XMM8');
  FReg64XMMIndex.ADD('XMM9');
  FReg64XMMIndex.ADD('XMM10');
  FReg64XMMIndex.ADD('XMM11');
  FReg64XMMIndex.ADD('XMM12');
  FReg64XMMIndex.ADD('XMM13');
  FReg64XMMIndex.ADD('XMM14');
  FReg64XMMIndex.ADD('XMM15');


  FReg64YMMIndex.ADD('YMM0');
  FReg64YMMIndex.ADD('YMM1');
  FReg64YMMIndex.ADD('YMM2');
  FReg64YMMIndex.ADD('YMM3');
  FReg64YMMIndex.ADD('YMM4');
  FReg64YMMIndex.ADD('YMM5');
  FReg64YMMIndex.ADD('YMM6');
  FReg64YMMIndex.ADD('YMM7');
  FReg64YMMIndex.ADD('YMM8');
  FReg64YMMIndex.ADD('YMM9');
  FReg64YMMIndex.ADD('YMM10');
  FReg64YMMIndex.ADD('YMM11');
  FReg64YMMIndex.ADD('YMM12');
  FReg64YMMIndex.ADD('YMM13');
  FReg64YMMIndex.ADD('YMM14');
  FReg64YMMIndex.ADD('YMM15');

  FReg64ZMMIndex.ADD('ZMM0');
  FReg64ZMMIndex.ADD('ZMM1');
  FReg64ZMMIndex.ADD('ZMM2');
  FReg64ZMMIndex.ADD('ZMM3');
  FReg64ZMMIndex.ADD('ZMM4');
  FReg64ZMMIndex.ADD('ZMM5');
  FReg64ZMMIndex.ADD('ZMM6');
  FReg64ZMMIndex.ADD('ZMM7');
  FReg64ZMMIndex.ADD('ZMM8');
  FReg64ZMMIndex.ADD('ZMM9');
  FReg64ZMMIndex.ADD('ZMM10');
  FReg64ZMMIndex.ADD('ZMM11');
  FReg64ZMMIndex.ADD('ZMM12');
  FReg64ZMMIndex.ADD('ZMM13');
  FReg64ZMMIndex.ADD('ZMM14');
  FReg64ZMMIndex.ADD('ZMM15');
  FReg64ZMMIndex.ADD('ZMM16');
  FReg64ZMMIndex.ADD('ZMM17');
  FReg64ZMMIndex.ADD('ZMM18');
  FReg64ZMMIndex.ADD('ZMM19');
  FReg64ZMMIndex.ADD('ZMM20');
  FReg64ZMMIndex.ADD('ZMM21');
  FReg64ZMMIndex.ADD('ZMM22');
  FReg64ZMMIndex.ADD('ZMM23');
  FReg64ZMMIndex.ADD('ZMM24');
  FReg64ZMMIndex.ADD('ZMM25');
  FReg64ZMMIndex.ADD('ZMM26');
  FReg64ZMMIndex.ADD('ZMM27');
  FReg64ZMMIndex.ADD('ZMM28');
  FReg64ZMMIndex.ADD('ZMM29');
  FReg64ZMMIndex.ADD('ZMM30');
  FReg64ZMMIndex.ADD('ZMM31');

  FRegKREG.ADD('K0');
  FRegKREG.ADD('K1');
  FRegKREG.ADD('K2');
  FRegKREG.ADD('K3');
  FRegKREG.ADD('K4');
  FRegKREG.ADD('K5');
  FRegKREG.ADD('K6');
  FRegKREG.ADD('K7');

end;

destructor TAsmTestGenerator.Destroy;
begin
  FreeAndNil(FReg8);
  FreeAndNil(FReg16);

  FreeAndNil(FReg32Base);
  FreeAndNil(FReg32Index);
  FreeAndNil(FReg64Base);
  FreeAndNil(FReg64Index);
  FreeAndNil(FReg6432Base);
  FreeAndNil(FReg6432Index);

  FreeAndNil(FReg32XMMIndex);
  FreeAndNil(FReg32YMMIndex);
  FreeAndNil(FReg32ZMMIndex);
  FreeAndNil(FReg64XMMIndex);
  FreeAndNil(FReg64YMMIndex);
  FreeAndNil(FReg64ZMMIndex);

  FreeAndnil(FRegKREG);

  inherited;
end;

procedure TAsmTestGenerator.MemRegBaseIndexCombi(const aPrefix, aSuffix: String; aSLBaseReg,
  aSLIndexReg, aRList: TStringList);
var
  il_Base: integer;
  il_Index: integer;
begin
  if not FGas then
  begin
    for il_Base := 0 to aSLBaseReg.Count - 1 do
    begin
      aRList.Add(format(aPrefix + '[%s]%s', [aSLBaseReg[il_Base], aSuffix]));

      for il_Index := 0 to aSLIndexReg.Count - 1 do
      begin
        aRList.Add(format(aPrefix + '[%s + %s]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s + $10]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s + $40]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s - $10]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s - $40]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));


        aRList.Add(format(aPrefix + '[%s + %s * 2]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 4]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 8]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        aRList.Add(format(aPrefix + '[%s + %s * 2 + 16]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 4 + 32]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 8 + 64]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
      end;
    end;
  end else
  begin
    for il_Base := 0 to aSLBaseReg.Count - 1 do
    begin
      aRList.Add(format(aPrefix + '(%s)%s', [aSLBaseReg[il_Base], aSuffix]));

      for il_Index := 0 to aSLIndexReg.Count - 1 do
      begin
        aRList.Add(format(aPrefix + '(%s,%s,1)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '16(%s,%s,1)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '64(%s,%s,1)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '-16(%s,%s,1)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '-64(%s,%s,1)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));


        aRList.Add(format(aPrefix + '(%s,%s,2)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '(%s,%s,4)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '(%s,%s,8)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        aRList.Add(format(aPrefix + '16(%s,%s,2)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '32(%s,%s,4)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '64(%s,%s,8)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
      end;
    end;
  end;
end;

procedure TAsmTestGenerator.MemRegBaseIndexCombiCDISP8N(const aPrefix,
  aSuffix: String; aSLBaseReg, aSLIndexReg, aRList: TStringList);
var
  iBase: integer;
  iIndex: integer;
  iOffset: integer;
begin

  for iBase := 0 to aSLBaseReg.Count - 1 do
  begin
    for iOffset := 0 to 63 do
    begin
      aRList.Add(format(aPrefix + '[%s +%2d]', [aSLBaseReg[iBase], iOffset]));

      for iIndex := 0 to aSLIndexReg.Count - 1 do
      begin
        if aSLBaseReg[iBase] <> aSLIndexReg[iIndex] then
        begin
          aRList.Add(format(aPrefix + '[%s + %s + %2d]', [aSLBaseReg[iBase], aSLIndexReg[iIndex], iOffset]));
          aRList.Add(format(aPrefix + '[%s + %s * 2 + %2d]', [aSLBaseReg[iBase], aSLIndexReg[iIndex], iOffset]));
          aRList.Add(format(aPrefix + '[%s + %s * 4 + %2d]', [aSLBaseReg[iBase], aSLIndexReg[iIndex], iOffset]));
          aRList.Add(format(aPrefix + '[%s + %s * 8 + %2d]', [aSLBaseReg[iBase], aSLIndexReg[iIndex], iOffset]));
        end;
      end;
    end;
  end;
end;

procedure TAsmTestGenerator.VectorMemRegBaseIndexCombi(const aPrefix, aSuffix: String;
  aSLBaseReg, aSLIndexReg, aRList: TStringList);
var
  il_Base: integer;
  il_Index: integer;
begin
  if not FGas then
  begin
    for il_Base := 0 to aSLBaseReg.Count - 1 do
    begin
      for il_Index := 0 to aSLIndexReg.Count - 1 do
      begin
        aRList.Add(format(aPrefix + '[%s + %s]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        aRList.Add(format(aPrefix + '[%s + %s * 2]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 4]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '[%s + %s * 8]%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        //aRList.Add(format(aPrefix + '[%s + %s * 2 + 16]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));
        //aRList.Add(format(aPrefix + '[%s + %s * 4 + 32]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));
        //aRList.Add(format(aPrefix + '[%s + %s * 8 + 48]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));

        aRList.Add(format(aPrefix + '[%s + %s]%s', [aSLIndexReg[il_Index], aSLBaseReg[il_Base], aSuffix]));
      end;
    end;
  end else
  begin
    for il_Base := 0 to aSLBaseReg.Count - 1 do
    begin
      for il_Index := 0 to aSLIndexReg.Count - 1 do
      begin
        aRList.Add(format(aPrefix + '(%s,%s)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        aRList.Add(format(aPrefix + '(%s,%s,2)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '(%s,%s,4)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));
        aRList.Add(format(aPrefix + '(%s,%s,8)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix]));

        //aRList.Add(format(aPrefix + '[%s + %s * 2 + 16]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));
        //aRList.Add(format(aPrefix + '[%s + %s * 4 + 32]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));
        //aRList.Add(format(aPrefix + '[%s + %s * 8 + 48]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]]));

        aRList.Add(format(aPrefix + '(%s,%s)%s', [aSLBaseReg[il_Base], aSLIndexReg[il_Index], aSuffix])); //-- normal base-index order for Gas
      end;
    end;
  end;
end;

function TAsmTestGenerator.ParseBaseIndexReg(const aOp: string; var aBaseReg,
  aIndexReg: string): boolean;
var
  iStartPos: integer;
  iEndPos: integer;
  iPos: integer;
  sOp: string;
  sBaseReg: string;
  sIndexReg: string;
begin
  result := false;

  aBaseReg  := '';
  aIndexReg := '';

  iStartPos := Pos('[', aOp);
  iEndPos   := Pos(']', aOp);

  if (iStartPos > 0) and
     (iEndPos > 0) and
     (iStartPos < iEndPos) then
  begin
    sOp  := trim(copy(aOp, iStartPos + 1, iEndPos - iStartPos - 1));

    with TStringList.Create do
    try
      CommaText := StringReplace(sOp, '+', ',', [rfReplaceAll]);

      while Count < 2 do Add('');

      sBaseReg := trim(Strings[0]);

      if (FReg32Base.IndexOf(sBasereg) >= 0) or
         (FReg64Base.IndexOf(sBasereg) >= 0) or
         (FReg6432Base.IndexOf(sBasereg) >= 0) then
       aBaseReg := sBaseReg;

      sIndexReg := trim(Strings[1]);

      if (FReg32Index.IndexOf(sIndexReg) >= 0) or
         (FReg64Index.IndexOf(sIndexReg) >= 0) or
         (FReg6432Index.IndexOf(sIndexReg) >= 0) then
       aIndexReg := sIndexReg;

      result := trim(aBasereg) <> '';
    finally
      Free;
    end;
  end;
end;

class procedure TAsmTestGenerator.CalcTestData(aGas, aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3,
  aOp4: String; aSL: TStringList);
var
  sl: TStringList;
begin
  with TAsmTestGenerator.Create(aGas) do
  try
    Fx64 := aX64;
    FAVX512 := aAVX512;
    FSAE    := aSAE;

    sl := InternalCalcTestData(aInst, aOp1, aOp2, aOp3, aOp4);
    try
      aSL.AddStrings(sl);
    finally
      FreeAndNil(sl);
    end;
  finally
    Free;
  end;
end;

class procedure TAsmTestGenerator.CalcTestDataMREF(aGas, aX64, aAVX512, aSAE: boolean; const aInst, aOp1, aOp2, aOp3,
  aOp4: String;  aSL: TStringList);
var
  sl: TStringList;
begin
  with TAsmTestGenerator.Create(aGas) do
  try
    Fx64 := aX64;
    FAVX512 := aAVX512;
    FSAE    := aSAE;

    sl := InternalCalcTestDataMREF(aInst, aOp1, aOp2, aOp3, aOp4);
    try
      aSL.AddStrings(sl);
    finally
      FreeAndNil(sl);
    end;
  finally
    Free;
  end;
end;

class procedure TAsmTestGenerator.CalcTestDataCDisp8(aGas, aX64, aAVX512,
  aSAE: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList);
var
  sl: TStringList;
begin
  with TAsmTestGenerator.Create(aGas) do
  try
    Fx64 := aX64;
    FAVX512 := aAVX512;
    FSAE    := aSAE;

    sl := InternalCalcTestDataCDisp8(aInst, aOp1, aOp2, aOp3, aOp4);
    try
      aSL.AddStrings(sl);
    finally
      FreeAndNil(sl);
    end;
  finally
    Free;
  end;
end;



class procedure TAsmTestGenerator.CalcTestInstFile;
var
  i,j: integer;
  sInst: string;
  sI386: string;
  sX8664: string;
  sAVX512: string;
  sOperands: string;
  sImmSize : String;

  sLine: string;


  sl: TStringList;
  bSSE: boolean;
  bVEX: boolean;
  bEVEX: boolean;
  b256 : boolean;
  b512 : boolean;
  ignoreCount:integer;
begin
  sl := TStringList.Create;
  try

    //tinsentry=packed record
    //  opcode  : tasmop;
    //  ops     : byte;
    //  //optypes : array[0..max_operands-1] of longint;
    //  optypes : array[0..3] of int64; //TG
    //  code    : array[0..11] of char;
    //  flags   : tinsflags;
    //end;

    for i := 0 to length(InsTab) - 1 do
    begin
      bSSE := false;
      bVEX := false;
      bEVEX := false;
      b256 := false;
      b512 := false;

      sImmSize:='IMM8,';
      ignoreCount:=0;

      //TG TODO delete
      if instab[i].opcode = a_vtestps then
      begin
        b512 := b512;
      end;

      for j := 0 to length(InsTab[i].code) - 1 do
      begin
        if ignoreCount>0 then
        begin
          dec(ignoreCount);
          continue;
        end;
        case ord(InsTab[i].code[j]) of
            0: break;
             1,2,3: ignoreCount:=ord(InsTab[i].code[j]);
          &10..&13: ignoreCount:=1;
          &40..&43: sImmSize:='IMM32,';
          232: bEVEX := true;
          233: b512 := true;
          242: bVEX := true;
          244: b256 := true;
        end;
      end;

      if not bVEX and not bEVEX then
        for j := 0 to InsTab[i].ops-1 do
          if InsTab[i].optypes[j] = OT_XMMREG then bSSE:=true;

      if bSSE or bVEX or bEVEX then
      begin
        sInst  :=  std_op2str[InsTab[i].opcode];
        sI386  := '1';
        sX8664 := '1';
        if IF_X86_64 in InsTab[i].flags then
        begin
          sI386  := '0';
        end;

        if bEVEX then sAVX512 := '1'
         else sAVX512 := '0';

        sOperands := '';
        for j := 0 to 3 do
        begin
          case InsTab[i].optypes[j] of
               OT_XMMREG: sOperands := sOperands + 'XMMREG,';
             OT_XMMREG_M: sOperands := sOperands + 'XMMREG_M,';
            OT_XMMREG_MZ: sOperands := sOperands + 'XMMREG_MZ,';
            OT_XMMREG_ER: sOperands := sOperands + 'XMMREG_ER,';
           OT_XMMREG_SAE: sOperands := sOperands + 'XMMREG_SAE,';
                OT_XMMRM: sOperands := sOperands + 'XMMRM,';
             OT_XMMRM_MZ: sOperands := sOperands + 'XMMRM_MZ,';

               OT_YMMREG: sOperands := sOperands + 'YMMREG,';
             OT_YMMREG_M: sOperands := sOperands + 'YMMREG_M,';
            OT_YMMREG_MZ: sOperands := sOperands + 'YMMREG_MZ,';
            OT_YMMREG_ER: sOperands := sOperands + 'YMMREG_ER,';
           OT_YMMREG_SAE: sOperands := sOperands + 'YMMREG_SAE,';
                OT_YMMRM: sOperands := sOperands + 'YMMRM,';
             OT_YMMRM_MZ: sOperands := sOperands + 'YMMRM_MZ,';

               OT_ZMMREG: sOperands := sOperands + 'ZMMREG,';
             OT_ZMMREG_M: sOperands := sOperands + 'ZMMREG_M,';
            OT_ZMMREG_MZ: sOperands := sOperands + 'ZMMREG_MZ,';
            OT_ZMMREG_ER: sOperands := sOperands + 'ZMMREG_ER,';
           OT_ZMMREG_SAE: sOperands := sOperands + 'ZMMREG_SAE,';
                OT_ZMMRM: sOperands := sOperands + 'ZMMRM,';
             OT_ZMMRM_MZ: sOperands := sOperands + 'ZMMRM_MZ,';

               OT_TMMREG: sOperands := sOperands + 'TMMREG,';

                 OT_MEM8: sOperands := sOperands + 'MEM8,';
                OT_MEM16: sOperands := sOperands + 'MEM16,';
              OT_MEM16_M: sOperands := sOperands + 'MEM16_M,';
                OT_MEM32: sOperands := sOperands + 'MEM32,';
              OT_MEM32_M: sOperands := sOperands + 'MEM32_M,';
                OT_MEM64: sOperands := sOperands + 'MEM64,';
              OT_MEM64_M: sOperands := sOperands + 'MEM64_M,';
               OT_MEM128: sOperands := sOperands + 'MEM128,';
             OT_MEM128_M: sOperands := sOperands + 'MEM128_M,';
               OT_MEM256: sOperands := sOperands + 'MEM256,';
             OT_MEM256_M: sOperands := sOperands + 'MEM256_M,';
               OT_MEM512: sOperands := sOperands + 'MEM512,';
             OT_MEM512_M: sOperands := sOperands + 'MEM512_M,';
               OT_SIBMEM: sOperands := sOperands + 'SIBMEM,';
               OT_MEMORY: sOperands := sOperands + 'MEM128,'; {any memory}

                OT_REG16: sOperands := sOperands + 'REG16,';
                OT_REG32: sOperands := sOperands + 'REG32,';
                OT_REG64: sOperands := sOperands + 'REG64,';
                 ot_rm_gpr or ot_bits16:
                          sOperands := sOperands + 'RM16,';
                 ot_rm_gpr or ot_bits32:
                          sOperands := sOperands + 'RM32,';
                 ot_rm_gpr or ot_bits64:
                          sOperands := sOperands + 'RM64,';

               OT_XMEM32: sOperands := sOperands + 'XMEM32,';
               OT_YMEM32: sOperands := sOperands + 'YMEM32,';
               OT_ZMEM32: sOperands := sOperands + 'ZMEM32,';
             OT_XMEM32_M: sOperands := sOperands + 'XMEM32_M,';
             OT_YMEM32_M: sOperands := sOperands + 'YMEM32_M,';
             OT_ZMEM32_M: sOperands := sOperands + 'ZMEM32_M,';
               OT_XMEM64: sOperands := sOperands + 'XMEM64,';
               OT_YMEM64: sOperands := sOperands + 'YMEM64,';
               OT_ZMEM64: sOperands := sOperands + 'ZMEM64,';
             OT_XMEM64_M: sOperands := sOperands + 'XMEM64_M,';
             OT_YMEM64_M: sOperands := sOperands + 'YMEM64_M,';
             OT_ZMEM64_M: sOperands := sOperands + 'ZMEM64_M,';

                 OT_IMM8: sOperands := sOperands + 'IMM8,';
            OT_IMMEDIATE: sOperands := sOperands + sImmSize;
                 OT_NONE: sOperands := sOperands + ',';
{

                     16      32     64
      IF_BCST2,                   '2B64,'
      IF_BCST4,            '4B32,''4B64,'
      IF_BCST8,    '8B16,' '8B32,''8B64,'
      IF_BCST16,  '16B16,''16B32,'
      IF_BCST32,  '32B16,'

}
               OT_BMEM16: begin
                            if b512 then
                            begin
                              if IF_BCST32 in instab[i].flags then  sOperands := sOperands + '32B16,'
                              else if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B32,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B64,'
                              else sOperands := sOperands + '32B16,'
                            end
                            else if b256 then
                            begin
                              if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B16,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B32,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B64,'
                              else sOperands := sOperands + '16B16,'
                            end else
                            begin
                              if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B16,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B32,'
                              else if IF_BCST2 in instab[i].flags then  sOperands := sOperands + '2B64,'
                              else sOperands := sOperands + '8B16,';
                            end;
                          end;
               OT_BMEM32: begin
                            if b512 then
                            begin
                              if IF_BCST32 in instab[i].flags then  sOperands := sOperands + '32B16,'
                              else if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B32,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B64,'
                              else sOperands := sOperands + '16B32,'
                            end
                            else if b256 then
                            begin
                              if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B16,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B32,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B64,'
                              else sOperands := sOperands + '8B32,'
                            end else
                            begin
                              if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B16,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B32,'
                              else if IF_BCST2 in instab[i].flags then  sOperands := sOperands + '2B64,'
                              else sOperands := sOperands + '4B32,';
                            end;
                          end;
               OT_BMEM64: begin
                            if b512 then
                            begin
                              if IF_BCST32 in instab[i].flags then  sOperands := sOperands + '32B16,'
                              else if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B32,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B64,'
                              else sOperands := sOperands + '8B64,'
                            end
                            else if b256 then
                            begin
                              if IF_BCST16 in instab[i].flags then  sOperands := sOperands + '16B16,'
                              else if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B32,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B64,'
                              else sOperands := sOperands + '4B64,'
                            end else
                            begin
                              if IF_BCST8 in instab[i].flags then  sOperands := sOperands + '8B16,'
                              else if IF_BCST4 in instab[i].flags then  sOperands := sOperands + '4B32,'
                              else if IF_BCST2 in instab[i].flags then  sOperands := sOperands + '2B64,'
                              else sOperands := sOperands + '2B64,';
                            end;
                          end;

                 OT_KREG: sOperands := sOperands + 'KREG,';
               OT_KREG_M: sOperands := sOperands + 'KREG_M,';

            else  sOperands := sOperands;
          end;
        end;

        sOperands := copy(sOperands, 1, length(sOperands) - 1);

        sl.Add(format('FOpCodeList.Add(''%s,%s,%s,%s,%s'');', [sInst, sI386, sX8664, sAVX512, sOperands]));
      end;

    end;

    sl.Savetofile('/tmp/fpcavx512.txt');

   // std_op2str

  finally
    FreeAndnil(sl);
  end;
end;

class procedure TAsmTestGenerator.ListMemRefState;
var
  i: integer;
  sGasSufffix: string;
  mrsize: TMemRefSizeInfo;
  opcode: tasmop;
  sl: TStringList;
  slEmpty: TStringList;
begin
  BuildInsTabCache;
  BuildInsTabMemRefSizeInfoCache;

  slEmpty := TStringList.Create;
  try
    for mrsize := low(TMemRefSizeInfo) to high(TMemRefSizeInfo) do
    begin

      sl := TStringList.Create;
      try
        for opcode:=low(tasmop) to high(tasmop) do
        begin
          if InsTabMemRefSizeInfoCache^[opcode].MemRefSize = mrsize then
          begin
            sGasSufffix:='';
            if gas_needsuffix[opcode] <> AttSufNone then
             sGasSufffix:=GetEnumName(Typeinfo(TAttSuffix), ord(gas_needsuffix[opcode]));

            sl.add(format('%-25s:   %s: %s', [GetEnumName(Typeinfo(TMemRefSizeInfo), ord(mrsize)), std_op2str[opcode], sGasSufffix]));
          end;
        end;

        sl.Sort;

        if sl.Count > 0 then
        begin
          writeln;

          writeln(sl.text);
        end
        else slEmpty.Add(GetEnumName(Typeinfo(TMemRefSizeInfo), ord(mrsize)));


      finally
        FreeAndNil(sl);
      end;
    end;

    slEmpty.Sort;
    writeln('');
    writeln(slEmpty.Text);
  finally
    FreeAndNil(slEmpty);
  end;

  if assigned(instabcache) then
  begin
    dispose(instabcache);
    instabcache:=nil;
  end;

  if assigned(InsTabMemRefSizeInfoCache) then
  begin
    dispose(InsTabMemRefSizeInfoCache);
    InsTabMemRefSizeInfoCache:=nil;
  end;


end;

end.