--- Merging r20490 into '.':

U    compiler\i386\r386nasm.inc
U    compiler\i386\r386nor.inc
U    compiler\i386\r386num.inc
U    compiler\i386\i386op.inc
U    compiler\i386\r386ari.inc
U    compiler\i386\i386att.inc
U    compiler\i386\i386int.inc
U    compiler\i386\r386iri.inc
U    compiler\i386\r386rni.inc
U    compiler\i386\r386nri.inc
U    compiler\i386\r386att.inc
U    compiler\i386\r386stab.inc
U    compiler\i386\r386std.inc
U    compiler\i386\r386int.inc
U    compiler\i386\r386sri.inc
U    compiler\i386\i386tab.inc
U    compiler\i386\daopt386.pas
U    compiler\i386\cpubase.inc
U    compiler\i386\r386dwrf.inc
U    compiler\i386\i386atts.inc
U    compiler\i386\i386prop.inc
U    compiler\i386\r386op.inc
U    compiler\i386\r386con.inc
U    compiler\i386\r386ot.inc
U    compiler\i386\i386nop.inc
U    compiler\x86_64\r8664sri.inc
U    compiler\x86_64\x8664ats.inc
U    compiler\x86_64\x8664att.inc
U    compiler\x86_64\x8664int.inc
U    compiler\x86_64\x8664pro.inc
U    compiler\x86_64\x8664tab.inc
U    compiler\x86_64\r8664con.inc
U    compiler\x86_64\r8664stab.inc
U    compiler\x86_64\r8664nor.inc
U    compiler\x86_64\r8664num.inc
U    compiler\x86_64\x8664nop.inc
U    compiler\x86_64\r8664dwrf.inc
U    compiler\x86_64\cpubase.inc
U    compiler\x86_64\r8664ari.inc
U    compiler\x86_64\r8664op.inc
U    compiler\x86_64\r8664ot.inc
U    compiler\x86_64\r8664iri.inc
U    compiler\x86_64\x8664op.inc
U    compiler\x86_64\r8664rni.inc
U    compiler\x86_64\r8664att.inc
U    compiler\x86_64\r8664std.inc
U    compiler\x86_64\r8664int.inc
U    compiler\cgbase.pas
U    compiler\ncal.pas
U    compiler\m68k\cgcpu.pas
U    compiler\x86\itx86int.pas
U    compiler\x86\cgx86.pas
U    compiler\x86\agx86att.pas
U    compiler\x86\x86reg.dat
U    compiler\x86\rax86.pas
U    compiler\x86\agx86int.pas
U    compiler\x86\itcpugas.pas
U    compiler\x86\cpubase.pas
U    compiler\x86\rax86int.pas
U    compiler\x86\x86ins.dat
U    compiler\x86\aasmcpu.pas
U    compiler\utils\mkx86reg.pp
U    compiler\utils\mkx86ins.pp
U    compiler\ppcgen\cgppc.pas
--- Recording mergeinfo for merge of r20490 into '.':
 U   .



git-svn-id: http://svn.freepascal.org/svn/fpc/branches/avx@21214 3ad0048d-3df7-0310-abae-a5850022a9f2

64 files changed, 11420 insertions, 276 deletions

diff --git a/compiler/cgbase.pas b/compiler/cgbase.pas
index 26a1ac6aee..ebf1441064 100644
--- a/compiler/cgbase.pas
+++ b/compiler/cgbase.pas
@@ -145,8 +145,8 @@ interface
                   OS_F32,OS_F64,OS_F80,OS_C64,OS_F128,
                  { multi-media sizes: split in byte, word, dword, ... }
                  { entities, then the signed counterparts             }
-                  OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,
-                  OS_MS8,OS_MS16,OS_MS32,OS_MS64,OS_MS128);
+                  OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M256,  
+                  OS_MS8,OS_MS16,OS_MS32,OS_MS64,OS_MS128,OS_MS256 );  
 
       { Register types }
       TRegisterType = (
@@ -174,7 +174,10 @@ interface
         R_SUBFQ,   { = 8; Float that allocates 4 FPU registers }
         R_SUBMMS,  { = 9; single scalar in multi media register }
         R_SUBMMD,  { = 10; double scalar in multi media register }
-        R_SUBMMWHOLE  { = 11; complete MM register, size depends on CPU }
+        R_SUBMMWHOLE,  { = 11; complete MM register, size depends on CPU }
+        { For Intel X86 AVX-Register }
+        R_SUBMMX,     { = 12; 128 BITS }
+        R_SUBMMY      { = 13; 256 BITS }
       );
       TSubRegisterSet = set of TSubRegister;
 
@@ -274,7 +277,7 @@ interface
          { floating point values }
          4,8,10,8,16,
          { multimedia values }
-         1,2,4,8,16,1,2,4,8,16);
+         1,2,4,8,16,32,1,2,4,8,16,32); 
 
        tfloat2tcgsize: array[tfloattype] of tcgsize =
          (OS_F32,OS_F64,OS_F80,OS_F80,OS_C64,OS_C64,OS_F128);
@@ -290,8 +293,8 @@ interface
        tcgsize2unsigned : array[tcgsize] of tcgsize = (OS_NO,
           OS_8,OS_16,OS_32,OS_64,OS_128,OS_8,OS_16,OS_32,OS_64,OS_128,
           OS_F32,OS_F64,OS_F80,OS_C64,OS_F128,
-          OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M8,OS_M16,OS_M32,
-          OS_M64,OS_M128);
+          OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M256,OS_M8,OS_M16,OS_M32,
+          OS_M64,OS_M128,OS_M256);
 
        tcgloc2str : array[TCGLoc] of string[12] = (
             'LOC_INVALID',
diff --git a/compiler/i386/cpubase.inc b/compiler/i386/cpubase.inc
index cadf3e29e2..7c26b21db9 100644
--- a/compiler/i386/cpubase.inc
+++ b/compiler/i386/cpubase.inc
@@ -34,7 +34,8 @@
         S_MD,
         S_NEAR,S_FAR,S_SHORT,
         S_T,
-        S_XMM
+        S_XMM,
+        S_YMM
       );
 
 
diff --git a/compiler/i386/daopt386.pas b/compiler/i386/daopt386.pas
index bdcaea11a2..82e45daeb6 100644
--- a/compiler/i386/daopt386.pas
+++ b/compiler/i386/daopt386.pas
@@ -58,6 +58,7 @@ const
     OS_M32,
     OS_ADDR,OS_NO,OS_NO,
     OS_NO,
+    OS_NO,
     OS_NO);
 
 
diff --git a/compiler/i386/i386att.inc b/compiler/i386/i386att.inc
index a591dad220..14ca3fbc0b 100644
--- a/compiler/i386/i386att.inc
+++ b/compiler/i386/i386att.inc
@@ -684,5 +684,264 @@
 'aeskeygenassist',
 'stosq',
 'lodsq',
-'cmpsq'
+'cmpsq',
+'vaddpd',
+'vaddps',
+'vaddsd',
+'vaddss',
+'vaddsubpd',
+'vaddsubps',
+'vaesdec',
+'vaesdeclast',
+'vaesenc',
+'vaesenclast',
+'vaesimc',
+'vaeskeygenassist',
+'vandnpd',
+'vandnps',
+'vandpd',
+'vandps',
+'vblendpd',
+'vblendps',
+'vblendvpd',
+'vblendvps',
+'vbroadcastf128',
+'vbroadcastsd',
+'vbroadcastss',
+'vcmppd',
+'vcmpps',
+'vcmpsd',
+'vcmpss',
+'vcomisd',
+'vcomiss',
+'vcvtdq2pd',
+'vcvtdq2ps',
+'vcvtpd2dq',
+'vcvtpd2ps',
+'vcvtps2dq',
+'vcvtps2pd',
+'vcvtsd2si',
+'vcvtsd2ss',
+'vcvtsi2sd',
+'vcvtsi2ss',
+'vcvtss2sd',
+'vcvtss2si',
+'vcvttpd2dq',
+'vcvttps2dq',
+'vcvttsd2si',
+'vcvttss2si',
+'vdivpd',
+'vdivps',
+'vdivsd',
+'vdivss',
+'vdppd',
+'vdpps',
+'vextractf128',
+'vextractps',
+'vhaddpd',
+'vhaddps',
+'vhsubpd',
+'vhsubps',
+'vinsertf128',
+'vinsertps',
+'vlddqu',
+'vldmxcsr',
+'vmaskmovdqu',
+'vmaskmovpd',
+'vmaskmovps',
+'vmaxpd',
+'vmaxps',
+'vmaxsd',
+'vmaxss',
+'vminpd',
+'vminps',
+'vminsd',
+'vminss',
+'vmovapd',
+'vmovaps',
+'vmovd',
+'vmovddup',
+'vmovdqa',
+'vmovdqu',
+'vmovhlps',
+'vmovhpd',
+'vmovhps',
+'vmovlhps',
+'vmovlpd',
+'vmovlps',
+'vmovmskpd',
+'vmovmskps',
+'vmovntdq',
+'vmovntdqa',
+'vmovntpd',
+'vmovntps',
+'vmovq',
+'vmovsd',
+'vmovshdup',
+'vmovsldup',
+'vmovss',
+'vmovupd',
+'vmovups',
+'vmpsadbw',
+'vmulpd',
+'vmulps',
+'vmulsd',
+'vmulss',
+'vorpd',
+'vorps',
+'vpabsb',
+'vpabsd',
+'vpabsw',
+'vpackssdw',
+'vpacksswb',
+'vpackusdw',
+'vpackuswb',
+'vpaddb',
+'vpaddd',
+'vpaddq',
+'vpaddsb',
+'vpaddsw',
+'vpaddusb',
+'vpaddusw',
+'vpaddw',
+'vpalignr',
+'vpand',
+'vpandn',
+'vpavgb',
+'vpavgw',
+'vpblendvb',
+'vpblendw',
+'vpclmulqdq',
+'vpcmpeqb',
+'vpcmpeqd',
+'vpcmpeqq',
+'vpcmpeqw',
+'vpcmpestri',
+'vpcmpestrm',
+'vpcmpgtb',
+'vpcmpgtd',
+'vpcmpgtq',
+'vpcmpgtw',
+'vpcmpistri',
+'vpcmpistrm',
+'vperm2f128',
+'vpermilpd',
+'vpermilps',
+'vpextrb',
+'vpextrd',
+'vpextrq',
+'vpextrw',
+'vphaddd',
+'vphaddsw',
+'vphaddw',
+'vphminposuw',
+'vphsubd',
+'vphsubsw',
+'vphsubw',
+'vpinsrb',
+'vpinsrd',
+'vpinsrq',
+'vpinsrw',
+'vpmaddubsw',
+'vpmaddwd',
+'vpmaxsb',
+'vpmaxsd',
+'vpmaxsw',
+'vpmaxub',
+'vpmaxud',
+'vpmaxuw',
+'vpminsb',
+'vpminsd',
+'vpminsw',
+'vpminub',
+'vpminud',
+'vpminuw',
+'vpmovmskb',
+'vpmovsxbd',
+'vpmovsxbq',
+'vpmovsxbw',
+'vpmovsxdq',
+'vpmovsxwd',
+'vpmovsxwq',
+'vpmovzxbd',
+'vpmovzxbq',
+'vpmovzxbw',
+'vpmovzxdq',
+'vpmovzxwd',
+'vpmovzxwq',
+'vpmuldq',
+'vpmulhrsw',
+'vpmulhuw',
+'vpmulhw',
+'vpmulld',
+'vpmullw',
+'vpmuludq',
+'vpor',
+'vpsadbw',
+'vpshufb',
+'vpshufd',
+'vpshufhw',
+'vpshuflw',
+'vpsignb',
+'vpsignd',
+'vpsignw',
+'vpslld',
+'vpslldq',
+'vpsllq',
+'vpsllw',
+'vpsrad',
+'vpsraw',
+'vpsrld',
+'vpsrldq',
+'vpsrlq',
+'vpsrlw',
+'vpsubb',
+'vpsubd',
+'vpsubq',
+'vpsubsb',
+'vpsubsw',
+'vpsubusb',
+'vpsubusw',
+'vpsubw',
+'vptest',
+'vpunpckhbw',
+'vpunpckhdq',
+'vpunpckhqdq',
+'vpunpckhwd',
+'vpunpcklbw',
+'vpunpckldq',
+'vpunpcklqdq',
+'vpunpcklwd',
+'vpxor',
+'vrcpps',
+'vrcpss',
+'vroundpd',
+'vroundps',
+'vroundsd',
+'vroundss',
+'vrsqrtps',
+'vrsqrtss',
+'vshufpd',
+'vshufps',
+'vsqrtpd',
+'vsqrtps',
+'vsqrtsd',
+'vsqrtss',
+'vstmxcsr',
+'vsubpd',
+'vsubps',
+'vsubsd',
+'vsubss',
+'vtestpd',
+'vtestps',
+'vucomisd',
+'vucomiss',
+'vunpckhpd',
+'vunpckhps',
+'vunpcklpd',
+'vunpcklps',
+'vxorpd',
+'vxorps',
+'vzeroall',
+'vzeroupper'
 );
diff --git a/compiler/i386/i386atts.inc b/compiler/i386/i386atts.inc
index 31bc9cd421..2f06270fe3 100644
--- a/compiler/i386/i386atts.inc
+++ b/compiler/i386/i386atts.inc
@@ -417,7 +417,7 @@ attsufNONE,
 attsufNONE,
 attsufNONE,
 attsufNONE,
-attsufINT,
+attsufMM,
 attsufINT,
 attsufNONE,
 attsufINT,
@@ -534,7 +534,7 @@ attsufNONE,
 attsufNONE,
 attsufINT,
 attsufNONE,
-attsufINT,
+attsufMM,
 attsufNONE,
 attsufNONE,
 attsufNONE,
@@ -684,5 +684,264 @@ attsufNONE,
 attsufNONE,
 attsufNONE,
 attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
 attsufNONE
 );
diff --git a/compiler/i386/i386int.inc b/compiler/i386/i386int.inc
index b6cc4caa78..3a3f4b4631 100644
--- a/compiler/i386/i386int.inc
+++ b/compiler/i386/i386int.inc
@@ -684,5 +684,264 @@
 'aeskeygenassist',
 'stosq',
 'lodsq',
-'cmpsq'
+'cmpsq',
+'vaddpd',
+'vaddps',
+'vaddsd',
+'vaddss',
+'vaddsubpd',
+'vaddsubps',
+'vaesdec',
+'vaesdeclast',
+'vaesenc',
+'vaesenclast',
+'vaesimc',
+'vaeskeygenassist',
+'vandnpd',
+'vandnps',
+'vandpd',
+'vandps',
+'vblendpd',
+'vblendps',
+'vblendvpd',
+'vblendvps',
+'vbroadcastf128',
+'vbroadcastsd',
+'vbroadcastss',
+'vcmppd',
+'vcmpps',
+'vcmpsd',
+'vcmpss',
+'vcomisd',
+'vcomiss',
+'vcvtdq2pd',
+'vcvtdq2ps',
+'vcvtpd2dq',
+'vcvtpd2ps',
+'vcvtps2dq',
+'vcvtps2pd',
+'vcvtsd2si',
+'vcvtsd2ss',
+'vcvtsi2sd',
+'vcvtsi2ss',
+'vcvtss2sd',
+'vcvtss2si',
+'vcvttpd2dq',
+'vcvttps2dq',
+'vcvttsd2si',
+'vcvttss2si',
+'vdivpd',
+'vdivps',
+'vdivsd',
+'vdivss',
+'vdppd',
+'vdpps',
+'vextractf128',
+'vextractps',
+'vhaddpd',
+'vhaddps',
+'vhsubpd',
+'vhsubps',
+'vinsertf128',
+'vinsertps',
+'vlddqu',
+'vldmxcsr',
+'vmaskmovdqu',
+'vmaskmovpd',
+'vmaskmovps',
+'vmaxpd',
+'vmaxps',
+'vmaxsd',
+'vmaxss',
+'vminpd',
+'vminps',
+'vminsd',
+'vminss',
+'vmovapd',
+'vmovaps',
+'vmovd',
+'vmovddup',
+'vmovdqa',
+'vmovdqu',
+'vmovhlps',
+'vmovhpd',
+'vmovhps',
+'vmovlhps',
+'vmovlpd',
+'vmovlps',
+'vmovmskpd',
+'vmovmskps',
+'vmovntdq',
+'vmovntdqa',
+'vmovntpd',
+'vmovntps',
+'vmovq',
+'vmovsd',
+'vmovshdup',
+'vmovsldup',
+'vmovss',
+'vmovupd',
+'vmovups',
+'vmpsadbw',
+'vmulpd',
+'vmulps',
+'vmulsd',
+'vmulss',
+'vorpd',
+'vorps',
+'vpabsb',
+'vpabsd',
+'vpabsw',
+'vpackssdw',
+'vpacksswb',
+'vpackusdw',
+'vpackuswb',
+'vpaddb',
+'vpaddd',
+'vpaddq',
+'vpaddsb',
+'vpaddsw',
+'vpaddusb',
+'vpaddusw',
+'vpaddw',
+'vpalignr',
+'vpand',
+'vpandn',
+'vpavgb',
+'vpavgw',
+'vpblendvb',
+'vpblendw',
+'vpclmulqdq',
+'vpcmpeqb',
+'vpcmpeqd',
+'vpcmpeqq',
+'vpcmpeqw',
+'vpcmpestri',
+'vpcmpestrm',
+'vpcmpgtb',
+'vpcmpgtd',
+'vpcmpgtq',
+'vpcmpgtw',
+'vpcmpistri',
+'vpcmpistrm',
+'vperm2f128',
+'vpermilpd',
+'vpermilps',
+'vpextrb',
+'vpextrd',
+'vpextrq',
+'vpextrw',
+'vphaddd',
+'vphaddsw',
+'vphaddw',
+'vphminposuw',
+'vphsubd',
+'vphsubsw',
+'vphsubw',
+'vpinsrb',
+'vpinsrd',
+'vpinsrq',
+'vpinsrw',
+'vpmaddubsw',
+'vpmaddwd',
+'vpmaxsb',
+'vpmaxsd',
+'vpmaxsw',
+'vpmaxub',
+'vpmaxud',
+'vpmaxuw',
+'vpminsb',
+'vpminsd',
+'vpminsw',
+'vpminub',
+'vpminud',
+'vpminuw',
+'vpmovmskb',
+'vpmovsxbd',
+'vpmovsxbq',
+'vpmovsxbw',
+'vpmovsxdq',
+'vpmovsxwd',
+'vpmovsxwq',
+'vpmovzxbd',
+'vpmovzxbq',
+'vpmovzxbw',
+'vpmovzxdq',
+'vpmovzxwd',
+'vpmovzxwq',
+'vpmuldq',
+'vpmulhrsw',
+'vpmulhuw',
+'vpmulhw',
+'vpmulld',
+'vpmullw',
+'vpmuludq',
+'vpor',
+'vpsadbw',
+'vpshufb',
+'vpshufd',
+'vpshufhw',
+'vpshuflw',
+'vpsignb',
+'vpsignd',
+'vpsignw',
+'vpslld',
+'vpslldq',
+'vpsllq',
+'vpsllw',
+'vpsrad',
+'vpsraw',
+'vpsrld',
+'vpsrldq',
+'vpsrlq',
+'vpsrlw',
+'vpsubb',
+'vpsubd',
+'vpsubq',
+'vpsubsb',
+'vpsubsw',
+'vpsubusb',
+'vpsubusw',
+'vpsubw',
+'vptest',
+'vpunpckhbw',
+'vpunpckhdq',
+'vpunpckhqdq',
+'vpunpckhwd',
+'vpunpcklbw',
+'vpunpckldq',
+'vpunpcklqdq',
+'vpunpcklwd',
+'vpxor',
+'vrcpps',
+'vrcpss',
+'vroundpd',
+'vroundps',
+'vroundsd',
+'vroundss',
+'vrsqrtps',
+'vrsqrtss',
+'vshufpd',
+'vshufps',
+'vsqrtpd',
+'vsqrtps',
+'vsqrtsd',
+'vsqrtss',
+'vstmxcsr',
+'vsubpd',
+'vsubps',
+'vsubsd',
+'vsubss',
+'vtestpd',
+'vtestps',
+'vucomisd',
+'vucomiss',
+'vunpckhpd',
+'vunpckhps',
+'vunpcklpd',
+'vunpcklps',
+'vxorpd',
+'vxorps',
+'vzeroall',
+'vzeroupper'
 );
diff --git a/compiler/i386/i386nop.inc b/compiler/i386/i386nop.inc
index 148db9c7eb..2c78c83758 100644
--- a/compiler/i386/i386nop.inc
+++ b/compiler/i386/i386nop.inc
@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86ins.dat }
-1208;
+1652;
diff --git a/compiler/i386/i386op.inc b/compiler/i386/i386op.inc
index 4070734e54..fbbb16b8c6 100644
--- a/compiler/i386/i386op.inc
+++ b/compiler/i386/i386op.inc
@@ -684,5 +684,264 @@ A_AESIMC,
 A_AESKEYGENASSIST,
 A_STOSQ,
 A_LODSQ,
-A_CMPSQ
+A_CMPSQ,
+A_VADDPD,
+A_VADDPS,
+A_VADDSD,
+A_VADDSS,
+A_VADDSUBPD,
+A_VADDSUBPS,
+A_VAESDEC,
+A_VAESDECLAST,
+A_VAESENC,
+A_VAESENCLAST,
+A_VAESIMC,
+A_VAESKEYGENASSIST,
+A_VANDNPD,
+A_VANDNPS,
+A_VANDPD,
+A_VANDPS,
+A_VBLENDPD,
+A_VBLENDPS,
+A_VBLENDVPD,
+A_VBLENDVPS,
+A_VBROADCASTF128,
+A_VBROADCASTSD,
+A_VBROADCASTSS,
+A_VCMPPD,
+A_VCMPPS,
+A_VCMPSD,
+A_VCMPSS,
+A_VCOMISD,
+A_VCOMISS,
+A_VCVTDQ2PD,
+A_VCVTDQ2PS,
+A_VCVTPD2DQ,
+A_VCVTPD2PS,
+A_VCVTPS2DQ,
+A_VCVTPS2PD,
+A_VCVTSD2SI,
+A_VCVTSD2SS,
+A_VCVTSI2SD,
+A_VCVTSI2SS,
+A_VCVTSS2SD,
+A_VCVTSS2SI,
+A_VCVTTPD2DQ,
+A_VCVTTPS2DQ,
+A_VCVTTSD2SI,
+A_VCVTTSS2SI,
+A_VDIVPD,
+A_VDIVPS,
+A_VDIVSD,
+A_VDIVSS,
+A_VDPPD,
+A_VDPPS,
+A_VEXTRACTF128,
+A_VEXTRACTPS,
+A_VHADDPD,
+A_VHADDPS,
+A_VHSUBPD,
+A_VHSUBPS,
+A_VINSERTF128,
+A_VINSERTPS,
+A_VLDDQU,
+A_VLDMXCSR,
+A_VMASKMOVDQU,
+A_VMASKMOVPD,
+A_VMASKMOVPS,
+A_VMAXPD,
+A_VMAXPS,
+A_VMAXSD,
+A_VMAXSS,
+A_VMINPD,
+A_VMINPS,
+A_VMINSD,
+A_VMINSS,
+A_VMOVAPD,
+A_VMOVAPS,
+A_VMOVD,
+A_VMOVDDUP,
+A_VMOVDQA,
+A_VMOVDQU,
+A_VMOVHLPS,
+A_VMOVHPD,
+A_VMOVHPS,
+A_VMOVLHPS,
+A_VMOVLPD,
+A_VMOVLPS,
+A_VMOVMSKPD,
+A_VMOVMSKPS,
+A_VMOVNTDQ,
+A_VMOVNTDQA,
+A_VMOVNTPD,
+A_VMOVNTPS,
+A_VMOVQ,
+A_VMOVSD,
+A_VMOVSHDUP,
+A_VMOVSLDUP,
+A_VMOVSS,
+A_VMOVUPD,
+A_VMOVUPS,
+A_VMPSADBW,
+A_VMULPD,
+A_VMULPS,
+A_VMULSD,
+A_VMULSS,
+A_VORPD,
+A_VORPS,
+A_VPABSB,
+A_VPABSD,
+A_VPABSW,
+A_VPACKSSDW,
+A_VPACKSSWB,
+A_VPACKUSDW,
+A_VPACKUSWB,
+A_VPADDB,
+A_VPADDD,
+A_VPADDQ,
+A_VPADDSB,
+A_VPADDSW,
+A_VPADDUSB,
+A_VPADDUSW,
+A_VPADDW,
+A_VPALIGNR,
+A_VPAND,
+A_VPANDN,
+A_VPAVGB,
+A_VPAVGW,
+A_VPBLENDVB,
+A_VPBLENDW,
+A_VPCLMULQDQ,
+A_VPCMPEQB,
+A_VPCMPEQD,
+A_VPCMPEQQ,
+A_VPCMPEQW,
+A_VPCMPESTRI,
+A_VPCMPESTRM,
+A_VPCMPGTB,
+A_VPCMPGTD,
+A_VPCMPGTQ,
+A_VPCMPGTW,
+A_VPCMPISTRI,
+A_VPCMPISTRM,
+A_VPERM2F128,
+A_VPERMILPD,
+A_VPERMILPS,
+A_VPEXTRB,
+A_VPEXTRD,
+A_VPEXTRQ,
+A_VPEXTRW,
+A_VPHADDD,
+A_VPHADDSW,
+A_VPHADDW,
+A_VPHMINPOSUW,
+A_VPHSUBD,
+A_VPHSUBSW,
+A_VPHSUBW,
+A_VPINSRB,
+A_VPINSRD,
+A_VPINSRQ,
+A_VPINSRW,
+A_VPMADDUBSW,
+A_VPMADDWD,
+A_VPMAXSB,
+A_VPMAXSD,
+A_VPMAXSW,
+A_VPMAXUB,
+A_VPMAXUD,
+A_VPMAXUW,
+A_VPMINSB,
+A_VPMINSD,
+A_VPMINSW,
+A_VPMINUB,
+A_VPMINUD,
+A_VPMINUW,
+A_VPMOVMSKB,
+A_VPMOVSXBD,
+A_VPMOVSXBQ,
+A_VPMOVSXBW,
+A_VPMOVSXDQ,
+A_VPMOVSXWD,
+A_VPMOVSXWQ,
+A_VPMOVZXBD,
+A_VPMOVZXBQ,
+A_VPMOVZXBW,
+A_VPMOVZXDQ,
+A_VPMOVZXWD,
+A_VPMOVZXWQ,
+A_VPMULDQ,
+A_VPMULHRSW,
+A_VPMULHUW,
+A_VPMULHW,
+A_VPMULLD,
+A_VPMULLW,
+A_VPMULUDQ,
+A_VPOR,
+A_VPSADBW,
+A_VPSHUFB,
+A_VPSHUFD,
+A_VPSHUFHW,
+A_VPSHUFLW,
+A_VPSIGNB,
+A_VPSIGND,
+A_VPSIGNW,
+A_VPSLLD,
+A_VPSLLDQ,
+A_VPSLLQ,
+A_VPSLLW,
+A_VPSRAD,
+A_VPSRAW,
+A_VPSRLD,
+A_VPSRLDQ,
+A_VPSRLQ,
+A_VPSRLW,
+A_VPSUBB,
+A_VPSUBD,
+A_VPSUBQ,
+A_VPSUBSB,
+A_VPSUBSW,
+A_VPSUBUSB,
+A_VPSUBUSW,
+A_VPSUBW,
+A_VPTEST,
+A_VPUNPCKHBW,
+A_VPUNPCKHDQ,
+A_VPUNPCKHQDQ,
+A_VPUNPCKHWD,
+A_VPUNPCKLBW,
+A_VPUNPCKLDQ,
+A_VPUNPCKLQDQ,
+A_VPUNPCKLWD,
+A_VPXOR,
+A_VRCPPS,
+A_VRCPSS,
+A_VROUNDPD,
+A_VROUNDPS,
+A_VROUNDSD,
+A_VROUNDSS,
+A_VRSQRTPS,
+A_VRSQRTSS,
+A_VSHUFPD,
+A_VSHUFPS,
+A_VSQRTPD,
+A_VSQRTPS,
+A_VSQRTSD,
+A_VSQRTSS,
+A_VSTMXCSR,
+A_VSUBPD,
+A_VSUBPS,
+A_VSUBSD,
+A_VSUBSS,
+A_VTESTPD,
+A_VTESTPS,
+A_VUCOMISD,
+A_VUCOMISS,
+A_VUNPCKHPD,
+A_VUNPCKHPS,
+A_VUNPCKLPD,
+A_VUNPCKLPS,
+A_VXORPD,
+A_VXORPS,
+A_VZEROALL,
+A_VZEROUPPER
 );
diff --git a/compiler/i386/i386prop.inc b/compiler/i386/i386prop.inc
index 4a8f2f7fa4..e57a923f65 100644
--- a/compiler/i386/i386prop.inc
+++ b/compiler/i386/i386prop.inc
@@ -684,5 +684,264 @@
 (Ch: (Ch_All, Ch_None, Ch_None)),
 (Ch: (Ch_RRAX, Ch_WMemEDI, Ch_RWRDI)),
 (Ch: (Ch_WRAX, Ch_RWRSI, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
 (Ch: (Ch_All, Ch_None, Ch_None))
 );
diff --git a/compiler/i386/i386tab.inc b/compiler/i386/i386tab.inc
index 0c427a24a4..540c88c512 100644
--- a/compiler/i386/i386tab.inc
+++ b/compiler/i386/i386tab.inc
@@ -4042,7 +4042,7 @@
   (
     opcode  : A_POR;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
     code    : #241#2#15#235#72;
     flags   : if_willamette or if_sse2 or if_sm
   ),
@@ -6142,21 +6142,14 @@
   (
     opcode  : A_CVTPI2PS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
-    code    : #217#2#15#42#72;
-    flags   : if_katmai or if_sse or if_mmx
-  ),
-  (
-    opcode  : A_CVTPI2PS;
-    ops     : 2;
-    optypes : (ot_xmmreg,ot_mmxreg,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_mmxrm,ot_none,ot_none);
     code    : #217#2#15#42#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
   (
     opcode  : A_CVTPS2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #217#2#15#45#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
@@ -6170,21 +6163,14 @@
   (
     opcode  : A_CVTSI2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
-    code    : #219#209#2#15#42#72;
-    flags   : if_katmai or if_sse
-  ),
-  (
-    opcode  : A_CVTSI2SS;
-    ops     : 2;
-    optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
     code    : #219#209#2#15#42#72;
     flags   : if_katmai or if_sse
   ),
   (
     opcode  : A_CVTSS2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none);
     code    : #219#208#2#15#45#72;
     flags   : if_katmai or if_sse
   ),
@@ -6198,7 +6184,7 @@
   (
     opcode  : A_CVTTPS2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #217#2#15#44#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
@@ -6212,7 +6198,7 @@
   (
     opcode  : A_CVTTSS2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none);
     code    : #219#208#2#15#44#72;
     flags   : if_katmai or if_sse
   ),
@@ -7143,7 +7129,14 @@
   (
     opcode  : A_CVTDQ2PD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #219#2#15#230#72;
+    flags   : if_willamette or if_sse2
+  ),
+  (
+    opcode  : A_CVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #219#2#15#230#72;
     flags   : if_willamette or if_sse2
   ),
@@ -7192,63 +7185,70 @@
   (
     opcode  : A_CVTPS2PD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #2#15#90#72;
+    flags   : if_willamette or if_sse2
+  ),
+  (
+    opcode  : A_CVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_xmmreg,ot_none,ot_none);
-    code    : #220#208#2#15#45#72;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#2#15#45#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
-    code    : #220#208#2#15#45#72;
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#2#15#45#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
     code    : #220#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
-    opcode  : A_CVTSI2SD;
+    opcode  : A_CVTSD2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none);
-    code    : #220#209#2#15#42#72;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSI2SD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
-    code    : #220#209#2#15#42#72;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
+    code    : #220#2#15#42#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSS2SD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
     code    : #219#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
-    opcode  : A_CVTTPD2PI;
+    opcode  : A_CVTSS2SD;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_xmmreg,ot_none,ot_none);
-    code    : #241#2#15#44#72;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTTPD2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_xmmrm,ot_none,ot_none);
     code    : #241#2#15#44#72;
     flags   : if_willamette or if_sse2
   ),
@@ -7276,7 +7276,7 @@
   (
     opcode  : A_CVTTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #220#208#2#15#44#72;
     flags   : if_willamette or if_sse2
   ),
@@ -8455,5 +8455,3113 @@
     optypes : (ot_xmmreg,ot_xmmrm,ot_immediate,ot_none);
     code    : #241#3#15#58#223#72#22;
     flags   : if_sse4 or if_sb or if_ar2
+  ),
+  (
+    opcode  : A_VADDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESDEC;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#222#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESDECLAST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#223#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESENC;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#220#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESENCLAST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#221#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESIMC;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#219#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESKEYGENASSIST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#223#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#13#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#13#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#12#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#12#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#75#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg);
+    code    : #241#242#244#250#1#75#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#74#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg);
+    code    : #241#242#244#250#1#74#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTF128;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #241#242#244#249#1#26#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#244#249#1#25#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#244#249#1#24#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#24#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #242#244#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #220#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #220#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #219#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #219#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #219#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_none,ot_none);
+    code    : #219#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #219#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #220#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #220#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#90#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#90#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPS2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2DQ;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #242#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#244#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSI2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none);
+    code    : #220#242#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_sd or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none);
+    code    : #220#242#243#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none);
+    code    : #219#242#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_sd or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none);
+    code    : #219#242#243#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTSS2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTTPS2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTPS2DQ;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#65#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#64#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#64#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VEXTRACTF128;
+    ops     : 3;
+    optypes : (ot_xmmrm,ot_ymmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#25#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VEXTRACTPS;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#23#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTF128;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#24#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#33#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#33#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #220#242#248#1#240#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDDQU;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits256,ot_none,ot_none);
+    code    : #220#242#244#248#1#240#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDMXCSR;
+    ops     : 1;
+    optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none);
+    code    : #242#248#1#174#130;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#247#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none);
+    code    : #241#242#244#249#1#47#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #241#242#249#1#47#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none);
+    code    : #241#242#244#249#1#45#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none);
+    code    : #241#242#249#1#45#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none);
+    code    : #241#242#244#249#1#46#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #241#242#249#1#46#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none);
+    code    : #241#242#244#249#1#44#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none);
+    code    : #241#242#249#1#44#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
+    code    : #241#242#248#1#110#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVD;
+    ops     : 2;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#126#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #220#242#244#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #219#242#244#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#23#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #241#242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#23#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#19#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #241#242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#19#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQ;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#231#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQ;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#231#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQA;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #241#242#249#1#42#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVQ;
+    ops     : 2;
+    optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#243#248#1#126#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none);
+    code    : #241#242#243#248#1#110#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#16#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#17#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSHDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#22#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSHDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#22#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSLDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSLDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#16#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #219#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#17#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMPSADBW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#66#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSB;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#28#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#30#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#29#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKSSDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#107#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKSSWB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#99#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKUSDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#43#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKUSWB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#103#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#252#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#254#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#212#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#236#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#237#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDUSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#220#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDUSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#221#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#253#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPALIGNR;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#15#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAND;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#219#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPANDN;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#223#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAVGB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#224#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAVGW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#227#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPBLENDVB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#76#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPBLENDW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#14#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCLMULQDQ;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#68#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#116#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#118#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#41#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#117#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPESTRI;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#97#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPESTRM;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#96#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#100#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#102#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#55#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#101#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPISTRI;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#99#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPISTRM;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#98#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERM2F128;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#6#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#249#1#13#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#5#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#5#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#13#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#249#1#12#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#4#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#4#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#12#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits8,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRD;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#22#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRQ;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#243#250#1#22#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#197#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#197#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits16,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#2#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#3#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#1#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHMINPOSUW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#65#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#6#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#7#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#5#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#32#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits8,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#32#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#34#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRQ;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_immediate or ot_bits8);
+    code    : #241#242#243#250#1#34#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#196#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits16,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#196#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMADDUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#4#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMADDWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#245#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#60#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#61#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#238#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#222#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#63#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#62#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#56#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#57#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#234#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#218#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#59#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#58#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVMSKB;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#215#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVMSKB;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#215#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#33#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#33#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none);
+    code    : #241#242#249#1#34#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#34#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#32#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#32#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#37#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#37#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#35#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#35#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#36#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#36#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#49#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#49#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none);
+    code    : #241#242#249#1#50#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#50#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#48#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#48#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#53#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#53#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#51#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#51#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#52#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#52#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#40#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHRSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#11#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#228#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#229#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#64#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#213#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULUDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#244#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPOR;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#235#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSADBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#246#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#0#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFHW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #219#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #220#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGNB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#8#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGND;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#10#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGNW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#9#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#242#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#143#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#243#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#241#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#140#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#226#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#140#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#225#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#210#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#139#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#211#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#209#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#248#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#250#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#251#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#232#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#233#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBUSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#216#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBUSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#217#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#249#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPTEST;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#23#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPTEST;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#23#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#104#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#106#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHQDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#109#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#105#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#96#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#98#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLQDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#108#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#97#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPXOR;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#239#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#83#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#83#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#83#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#83#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#9#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#9#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#8#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#8#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#11#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#11#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#10#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#10#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#82#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#82#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#82#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#82#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #242#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #242#244#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSTMXCSR;
+    ops     : 1;
+    optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none);
+    code    : #242#248#1#174#131;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#15#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#15#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#14#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#14#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VZEROALL;
+    ops     : 0;
+    optypes : (ot_none,ot_none,ot_none,ot_none);
+    code    : #242#244#248#1#119;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VZEROUPPER;
+    ops     : 0;
+    optypes : (ot_none,ot_none,ot_none,ot_none);
+    code    : #242#248#1#119;
+    flags   : if_avx or if_sandybridge
   )
 );
diff --git a/compiler/i386/r386ari.inc b/compiler/i386/r386ari.inc
index 485e9d94a4..fd59f7d09b 100644
--- a/compiler/i386/r386ari.inc
+++ b/compiler/i386/r386ari.inc
@@ -70,4 +70,12 @@
 69,
 70,
 71,
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
 0
diff --git a/compiler/i386/r386att.inc b/compiler/i386/r386att.inc
index 2efe472cd4..126b745a71 100644
--- a/compiler/i386/r386att.inc
+++ b/compiler/i386/r386att.inc
@@ -70,4 +70,12 @@
 '%xmm4',
 '%xmm5',
 '%xmm6',
-'%xmm7'
+'%xmm7',
+'%ymm0',
+'%ymm1',
+'%ymm2',
+'%ymm3',
+'%ymm4',
+'%ymm5',
+'%ymm6',
+'%ymm7'
diff --git a/compiler/i386/r386con.inc b/compiler/i386/r386con.inc
index eb1f3d0a78..5e58d92176 100644
--- a/compiler/i386/r386con.inc
+++ b/compiler/i386/r386con.inc
@@ -63,11 +63,19 @@ NR_MM4 = tregister($03000004);
 NR_MM5 = tregister($03000005);
 NR_MM6 = tregister($03000006);
 NR_MM7 = tregister($03000007);
-NR_XMM0 = tregister($04000000);
-NR_XMM1 = tregister($04000001);
-NR_XMM2 = tregister($04000002);
-NR_XMM3 = tregister($04000003);
-NR_XMM4 = tregister($04000004);
-NR_XMM5 = tregister($04000005);
-NR_XMM6 = tregister($04000006);
-NR_XMM7 = tregister($04000007);
+NR_XMM0 = tregister($040C0000);
+NR_XMM1 = tregister($040C0001);
+NR_XMM2 = tregister($040C0002);
+NR_XMM3 = tregister($040C0003);
+NR_XMM4 = tregister($040C0004);
+NR_XMM5 = tregister($040C0005);
+NR_XMM6 = tregister($040C0006);
+NR_XMM7 = tregister($040C0007);
+NR_YMM0 = tregister($040D0000);
+NR_YMM1 = tregister($040D0001);
+NR_YMM2 = tregister($040D0002);
+NR_YMM3 = tregister($040D0003);
+NR_YMM4 = tregister($040D0004);
+NR_YMM5 = tregister($040D0005);
+NR_YMM6 = tregister($040D0006);
+NR_YMM7 = tregister($040D0007);
diff --git a/compiler/i386/r386dwrf.inc b/compiler/i386/r386dwrf.inc
index 79d6522842..20cdf5e6a9 100644
--- a/compiler/i386/r386dwrf.inc
+++ b/compiler/i386/r386dwrf.inc
@@ -70,4 +70,12 @@
 25,
 26,
 27,
+28,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
 28
diff --git a/compiler/i386/r386int.inc b/compiler/i386/r386int.inc
index 585a5b0285..3b439920e9 100644
--- a/compiler/i386/r386int.inc
+++ b/compiler/i386/r386int.inc
@@ -70,4 +70,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'
diff --git a/compiler/i386/r386iri.inc b/compiler/i386/r386iri.inc
index 33148cb940..c517f8ce98 100644
--- a/compiler/i386/r386iri.inc
+++ b/compiler/i386/r386iri.inc
@@ -70,4 +70,12 @@
 68,
 69,
 70,
-71
+71,
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79
diff --git a/compiler/i386/r386nasm.inc b/compiler/i386/r386nasm.inc
index 1e2bd036b0..d2230f90c4 100644
--- a/compiler/i386/r386nasm.inc
+++ b/compiler/i386/r386nasm.inc
@@ -70,4 +70,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'
diff --git a/compiler/i386/r386nor.inc b/compiler/i386/r386nor.inc
index 2e66b09488..4863b3012a 100644
--- a/compiler/i386/r386nor.inc
+++ b/compiler/i386/r386nor.inc
@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86reg.dat }
-72
+80
diff --git a/compiler/i386/r386nri.inc b/compiler/i386/r386nri.inc
index 33148cb940..c517f8ce98 100644
--- a/compiler/i386/r386nri.inc
+++ b/compiler/i386/r386nri.inc
@@ -70,4 +70,12 @@
 68,
 69,
 70,
-71
+71,
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79
diff --git a/compiler/i386/r386num.inc b/compiler/i386/r386num.inc
index 5762785a18..ff47f970cd 100644
--- a/compiler/i386/r386num.inc
+++ b/compiler/i386/r386num.inc
@@ -63,11 +63,19 @@ tregister($03000004),
 tregister($03000005),
 tregister($03000006),
 tregister($03000007),
-tregister($04000000),
-tregister($04000001),
-tregister($04000002),
-tregister($04000003),
-tregister($04000004),
-tregister($04000005),
-tregister($04000006),
-tregister($04000007)
+tregister($040C0000),
+tregister($040C0001),
+tregister($040C0002),
+tregister($040C0003),
+tregister($040C0004),
+tregister($040C0005),
+tregister($040C0006),
+tregister($040C0007),
+tregister($040D0000),
+tregister($040D0001),
+tregister($040D0002),
+tregister($040D0003),
+tregister($040D0004),
+tregister($040D0005),
+tregister($040D0006),
+tregister($040D0007)
diff --git a/compiler/i386/r386op.inc b/compiler/i386/r386op.inc
index c9df7fabcb..81df882978 100644
--- a/compiler/i386/r386op.inc
+++ b/compiler/i386/r386op.inc
@@ -70,4 +70,12 @@
 4,
 5,
 6,
+7,
+0,
+1,
+2,
+3,
+4,
+5,
+6,
 7
diff --git a/compiler/i386/r386ot.inc b/compiler/i386/r386ot.inc
index d30c918dc7..9b403f9db1 100644
--- a/compiler/i386/r386ot.inc
+++ b/compiler/i386/r386ot.inc
@@ -70,4 +70,12 @@ OT_XMMREG,
 OT_XMMREG,
 OT_XMMREG,
 OT_XMMREG,
-OT_XMMREG
+OT_XMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG
diff --git a/compiler/i386/r386rni.inc b/compiler/i386/r386rni.inc
index 294022d5e2..77bd7520a0 100644
--- a/compiler/i386/r386rni.inc
+++ b/compiler/i386/r386rni.inc
@@ -49,6 +49,14 @@
 69,
 70,
 71,
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
 25,
 26,
 27,
diff --git a/compiler/i386/r386sri.inc b/compiler/i386/r386sri.inc
index 33148cb940..c517f8ce98 100644
--- a/compiler/i386/r386sri.inc
+++ b/compiler/i386/r386sri.inc
@@ -70,4 +70,12 @@
 68,
 69,
 70,
-71
+71,
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79
diff --git a/compiler/i386/r386stab.inc b/compiler/i386/r386stab.inc
index d2fbf4d7e5..d7c15d7b6f 100644
--- a/compiler/i386/r386stab.inc
+++ b/compiler/i386/r386stab.inc
@@ -70,4 +70,12 @@
 25,
 26,
 27,
+28,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
 28
diff --git a/compiler/i386/r386std.inc b/compiler/i386/r386std.inc
index 585a5b0285..3b439920e9 100644
--- a/compiler/i386/r386std.inc
+++ b/compiler/i386/r386std.inc
@@ -70,4 +70,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'
diff --git a/compiler/m68k/cgcpu.pas b/compiler/m68k/cgcpu.pas
index a98ffce61b..fd00d8da7d 100644
--- a/compiler/m68k/cgcpu.pas
+++ b/compiler/m68k/cgcpu.pas
@@ -128,7 +128,8 @@ unit cgcpu;
       TCGSize2OpSize: Array[tcgsize] of topsize =
         (S_NO,S_B,S_W,S_L,S_L,S_NO,S_B,S_W,S_L,S_L,S_NO,
          S_FS,S_FD,S_FX,S_NO,S_NO,
-         S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO);
+         S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,
+         S_NO,S_NO,S_NO,S_NO,S_NO,S_NO);
 
     procedure create_codegen;
 
diff --git a/compiler/ncal.pas b/compiler/ncal.pas
index 73ca618ae6..fdd753a068 100644
--- a/compiler/ncal.pas
+++ b/compiler/ncal.pas
@@ -3822,11 +3822,8 @@ implementation
                 { otherwise if the parameter is "complex", take the address   }
                 { of the parameter expression, store it in a temp and replace }
                 { occurrences of the parameter with dereferencings of this    }
-                { temp                                    }
-                else
-                  { don't create a temp. for the often seen case that p^ is passed to a var parameter }
-                  if (paracomplexity>2) or
-                    ((paracomplexity>1) and not((para.left.nodetype=derefn) and (para.parasym.varspez = vs_var))) then
+                { temp                                                        }
+                else if (paracomplexity > 1) then
                   begin
                     wrapcomplexinlinepara(para);
                   end;
diff --git a/compiler/ppcgen/cgppc.pas b/compiler/ppcgen/cgppc.pas
index ad500fc52a..3ffa4f5da2 100644
--- a/compiler/ppcgen/cgppc.pas
+++ b/compiler/ppcgen/cgppc.pas
@@ -160,8 +160,8 @@ unit cgppc;
          cgsize_strings : array[TCgSize] of string[8] = (
            'OS_NO', 'OS_8', 'OS_16', 'OS_32', 'OS_64', 'OS_128', 'OS_S8', 'OS_S16', 'OS_S32',
            'OS_S64', 'OS_S128', 'OS_F32', 'OS_F64', 'OS_F80', 'OS_C64', 'OS_F128',
-           'OS_M8', 'OS_M16', 'OS_M32', 'OS_M64', 'OS_M128', 'OS_MS8', 'OS_MS16', 'OS_MS32',
-           'OS_MS64', 'OS_MS128');
+           'OS_M8', 'OS_M16', 'OS_M32', 'OS_M64', 'OS_M128', 'OS_M256', 'OS_MS8', 'OS_MS16', 'OS_MS32',
+           'OS_MS64', 'OS_MS128', 'OS_MS256');
        begin
          result := cgsize_strings[size];
        end;
diff --git a/compiler/utils/mkx86ins.pp b/compiler/utils/mkx86ins.pp
index 72cbc8b5cb..27b206c972 100644
--- a/compiler/utils/mkx86ins.pp
+++ b/compiler/utils/mkx86ins.pp
@@ -56,7 +56,7 @@ var
 
 function formatop(s:string;allowsizeonly:boolean):string;
    const
-     replaces=26;
+     replaces=28;
      replacetab : array[1..replaces,1..2] of string[32]=(
        (':',' or ot_colon'),
        ('reg','regnorm'),
@@ -70,6 +70,8 @@ function formatop(s:string;allowsizeonly:boolean):string;
        ('mem16','memory or ot_bits16'),
        ('mem32','memory or ot_bits32'),
        ('mem64','memory or ot_bits64'),
+       ('mem128','memory or ot_bits128'),
+       ('mem256','memory or ot_bits256'),
        ('mem80','memory or ot_bits80'),
        ('mem','memory'),
        ('memory_offs','mem_offs'),
@@ -269,6 +271,11 @@ begin
               attopcode:=Copy(s,i+1,j-i-1);
               { att Suffix }
               case attopcode[length(attopcode)] of
+                'M' :
+                  begin
+                    dec(attopcode[0]);
+                    attsuffix:='attsufMM';
+                  end;
                 'X' :
                   begin
                     dec(attopcode[0]);
diff --git a/compiler/utils/mkx86reg.pp b/compiler/utils/mkx86reg.pp
index bce54ba519..06967358b5 100644
--- a/compiler/utils/mkx86reg.pp
+++ b/compiler/utils/mkx86reg.pp
@@ -17,7 +17,7 @@
 program mkx86reg;
 
 const Version = '1.00';
-      max_regcount = 128;
+      max_regcount = 200;
 
 var s : string;
     i : longint;
diff --git a/compiler/x86/aasmcpu.pas b/compiler/x86/aasmcpu.pas
index dc7d7cee8a..25219a3eb7 100644
--- a/compiler/x86/aasmcpu.pas
+++ b/compiler/x86/aasmcpu.pas
@@ -51,6 +51,8 @@ interface
       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_BITS80    = $00000010;  { FPU only  }
       OT_FAR       = $00000020;  { this means 16:16 or 16:32, like in CALL/JMP }
       OT_NEAR      = $00000040;
@@ -58,7 +60,7 @@ interface
 
       { TODO: FAR/NEAR/SHORT are sizes too, they should be included into size mask,
         but this requires adjusting the opcode table }
-      OT_SIZE_MASK = $0000001F;  { all the size attributes  }
+      OT_SIZE_MASK = $3000001F;  { all the size attributes  }
       OT_NON_SIZE  = longint(not OT_SIZE_MASK);
 
       { Bits 8..11: modifiers }
@@ -84,6 +86,7 @@ interface
       otf_reg_fpu  = $01000000;
       otf_reg_mmx  = $02000000;
       otf_reg_xmm  = $04000000;
+      otf_reg_ymm  = $08000000;
       { Bits 16..19: subclasses, meaning depends on classes field }
       otf_sub0     = $00010000;
       otf_sub1     = $00020000;
@@ -148,18 +151,24 @@ interface
       OT_XMMREG    = OT_REGNORM or otf_reg_xmm;
       OT_XMMRM     = OT_REGMEM or otf_reg_xmm;
 
+      { register class 5: XMM (both reg and r/m) }
+      OT_YMMREG    = OT_REGNORM or otf_reg_ymm;
+      OT_YMMRM     = OT_REGMEM or otf_reg_ymm;
+
       { Memory operands }
       OT_MEM8      = OT_MEMORY or OT_BITS8;
       OT_MEM16     = OT_MEMORY or OT_BITS16;
       OT_MEM32     = OT_MEMORY or OT_BITS32;
       OT_MEM64     = OT_MEMORY or OT_BITS64;
+      OT_MEM128    = OT_MEMORY or OT_BITS128;
+      OT_MEM256    = OT_MEMORY or OT_BITS256;
       OT_MEM80     = OT_MEMORY or OT_BITS80;
 
       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;
+      OT_MEMORY_ANY = OT_MEMORY or OT_RM_GPR or OT_XMMRM or OT_MMXRM or OT_YMMRM;
 
       { Immediate operands }
       OT_IMM8      = OT_IMMEDIATE or OT_BITS8;
@@ -212,6 +221,16 @@ interface
         Ch : Array[1..MaxInsChanges] of TInsChange;
       end;
 
+      TMemRefSizeInfo = (msiUnkown, msiMultiple, msiMemRegSize,
+                         msiMem8, msiMem16, msiMem32, msiMem64, msiMem128, msiMem256);
+
+      TConstSizeInfo  = (csiUnkown, csiMultiple, csiNoSize, csiMem8, csiMem16, csiMem32, csiMem64);
+
+      TInsTabMemRefSizeInfoRec = record
+        MemRefSize  : TMemRefSizeInfo;
+        ExistsSSEAVX: boolean;
+        ConstSize   : TConstSizeInfo;
+      end;
     const
       InsProp : array[tasmop] of TInsProp =
 {$ifdef x86_64}
@@ -228,7 +247,7 @@ interface
         ops     : byte;
         optypes : array[0..max_operands-1] of longint;
         code    : array[0..maxinfolen] of char;
-        flags   : cardinal;
+        flags   : int64;
       end;
       pinsentry=^tinsentry;
 
@@ -313,6 +332,8 @@ interface
     function spilling_create_load(const ref:treference;r:tregister):Taicpu;
     function spilling_create_store(r:tregister; const ref:treference):Taicpu;
 
+    function MemRefInfo(aAsmop: TAsmOp): TInsTabMemRefSizeInfoRec;
+
     procedure InitAsm;
     procedure DoneAsm;
 
@@ -345,6 +366,7 @@ implementation
        IF_AR2    = $00000060;  { SB, SW, SD applies to argument 2  }
        IF_ARMASK = $00000060;  { mask for unsized argument spec  }
        IF_ARSHIFT = 5;         { LSB of IF_ARMASK }
+       IF_SI     = $00000080;  { ignore unsized operands }
        IF_PRIV   = $00000100;  { it's a privileged instruction  }
        IF_SMM    = $00000200;  { it's only valid in SMM  }
        IF_PROT   = $00000400;  { it's protected mode only  }
@@ -375,6 +397,8 @@ implementation
        IF_SSSE3  = $00200000;
        IF_SSE41  = $00200000;
        IF_SSE42  = $00200000;
+       IF_AVX    = $00200000;
+       IF_SANDYBRIDGE = $00200000;
 
        IF_8086   = $00000000;  { 8086 instruction  }
        IF_186    = $01000000;  { 186+ instruction  }
@@ -400,6 +424,9 @@ implementation
        TInsTabCache=array[TasmOp] of longint;
        PInsTabCache=^TInsTabCache;
 
+       TInsTabMemRefSizeInfoCache=array[TasmOp] of TInsTabMemRefSizeInfoRec;
+       PInsTabMemRefSizeInfoCache=^TInsTabMemRefSizeInfoCache;
+
      const
 {$ifdef x86_64}
        InsTab:array[0..instabentries-1] of TInsEntry={$i x8664tab.inc}
@@ -408,7 +435,7 @@ implementation
 {$endif x86_64}
      var
        InsTabCache : PInsTabCache;
-
+       InsTabMemRefSizeInfoCache: PInsTabMemRefSizeInfoCache;
      const
 {$ifdef x86_64}
        { Intel style operands ! }
@@ -420,7 +447,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          ),
          (OT_NONE,
           OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_BITS8,OT_BITS8,OT_BITS16,OT_BITS8,OT_BITS16,OT_BITS32,
@@ -429,7 +457,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          ),
          (OT_NONE,
           OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_NONE,OT_NONE,OT_NONE,OT_NONE,OT_NONE,OT_NONE,
@@ -438,7 +467,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          )
        );
 
@@ -455,7 +485,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          ),
          (OT_NONE,
           OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_BITS8,OT_BITS8,OT_BITS16,
@@ -464,7 +495,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          ),
          (OT_NONE,
           OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_NONE,OT_NONE,OT_NONE,
@@ -473,7 +505,8 @@ implementation
           OT_BITS64,
           OT_NEAR,OT_FAR,OT_SHORT,
           OT_NONE,
-          OT_NONE
+          OT_BITS128,
+          OT_BITS256
          )
       );
 
@@ -482,6 +515,11 @@ implementation
       );
 {$endif x86_64}
 
+    function MemRefInfo(aAsmop: TAsmOp): TInsTabMemRefSizeInfoRec;
+    begin
+      result := InsTabMemRefSizeInfoCache^[aAsmop];
+    end;
+
     { Operation type for spilling code }
     type
       toperation_type_table=array[tasmop,0..Max_Operands] of topertype;
@@ -808,6 +846,9 @@ implementation
                if (ot and OT_XMMREG)=OT_XMMREG then
                 s:=s+'xmmreg'
                else
+                 if (ot and OT_YMMREG)=OT_YMMREG then
+                  s:=s+'ymmreg'
+               else
                  if (ot and OT_MMXREG)=OT_MMXREG then
                   s:=s+'mmxreg'
                else
@@ -848,6 +889,12 @@ implementation
                    if (ot and OT_BITS64)<>0 then
                     s:=s+'64'
                   else
+                   if (ot and OT_BITS128)<>0 then
+                    s:=s+'128'
+                  else
+                   if (ot and OT_BITS256)<>0 then
+                    s:=s+'256'
+                  else
                     s:=s+'??';
                   { signed }
                   if (ot and OT_SIGNED)<>0 then
@@ -1073,16 +1120,33 @@ implementation
                 end;
               top_const :
                 begin
-                  { allow 2nd, 3rd or 4th operand being a constant and expect no size for shuf* etc. }
-                  { further, allow AAD and AAM with imm. operand }
-                  if (opsize=S_NO) and not((i in [1,2,3]) or ((i=0) and (opcode in [A_AAD,A_AAM]))) then
-                    message(asmr_e_invalid_opcode_and_operand);
-                  if (opsize<>S_W) and (aint(val)>=-128) and (val<=127) then
-                    ot:=OT_IMM8 or OT_SIGNED
+                  // if opcode is a SSE or AVX-instruction then we need a
+                  // special handling (opsize can different from const-size)
+                  // (e.g. "pextrw  reg/m16, xmmreg, imm8" =>> opsize (16 bit), const-size (8 bit)
+                  if (InsTabMemRefSizeInfoCache^[opcode].ExistsSSEAVX) and
+                     (not(InsTabMemRefSizeInfoCache^[opcode].ConstSize in [csiMultiple, csiUnkown])) then
+                  begin
+                    case InsTabMemRefSizeInfoCache^[opcode].ConstSize of
+                      csiNoSize: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE;
+                        csiMem8: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS8;
+                       csiMem16: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS16;
+                       csiMem32: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS32;
+                       csiMem64: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS64;
+                    end;
+                  end
                   else
-                    ot:=OT_IMMEDIATE or opsize_2_type[i,opsize];
-                  if (val=1) and (i=1) then
-                    ot := ot or OT_ONENESS;
+                  begin
+                    { allow 2nd, 3rd or 4th operand being a constant and expect no size for shuf* etc. }
+                    { further, allow AAD and AAM with imm. operand }
+                    if (opsize=S_NO) and not((i in [1,2,3]) or ((i=0) and (opcode in [A_AAD,A_AAM]))) then
+                      message(asmr_e_invalid_opcode_and_operand);
+                    if (opsize<>S_W) and (aint(val)>=-128) and (val<=127) then
+                      ot:=OT_IMM8 or OT_SIGNED
+                    else
+                      ot:=OT_IMMEDIATE or opsize_2_type[i,opsize];
+                    if (val=1) and (i=1) then
+                      ot := ot or OT_ONENESS;
+                  end;
                 end;
               top_none :
                 begin
@@ -1208,6 +1272,48 @@ implementation
                     (((insot and OT_SIZE_MASK) or siz[i])<(currot and OT_SIZE_MASK)) then
                   exit;
               end;
+          end
+          else
+          begin
+              if insflags and IF_SI <> 0 then
+              begin
+                // any opcodes needed a unique mem-size for memory-operands
+                // in this time (e.g. CVTSI2SD, CVTSI2SS, VCVTPD2DQ, VCVTPD2PS, VCVTSI2SD, VCVTSI2SS, VCVTTPD2DQ)
+                // (e.g. "VCVTPD2DQ  xmmreg, mem128", "VCVTPD2DQ  xmmreg, mem256")
+                // =>> we need the exact mem-ref-size 
+
+                { Check operand sizes }
+                for i:=0 to p^.ops-1 do
+                begin
+                  insot:=p^.optypes[i];
+                  currot:=oper[i]^.ot;
+
+                  if ((currot and OT_MEMORY) = OT_MEMORY) then
+                  begin
+                    if (currot and OT_SIZE_MASK) = 0 then
+                    begin
+                      // no operand size for memory operand
+                      exit;
+                    end
+                    else
+                    begin
+                      if (insot and OT_XMMRM = OT_XMMRM) then
+                      begin
+                        if (currot and OT_SIZE_MASK) <> OT_BITS128 then
+                          exit;
+                      end
+                      else if (insot and OT_YMMRM = OT_YMMRM) then
+                      begin
+                        if (currot and OT_SIZE_MASK) <> OT_BITS256 then
+                          exit;
+                      end;
+                    end;
+                  end;
+                end;
+
+
+                // ignore operands without operand size
+              end;
           end;
 
         result:=true;
@@ -1729,12 +1835,22 @@ implementation
         c     : byte;
         len     : shortint;
         ea_data : ea;
+        exists_vex: boolean;
+        exists_vex_extention: boolean;
+        exists_prefix_66: boolean;
+        exists_prefix_F2: boolean;
+        exists_prefix_F3: boolean;
 {$ifdef x86_64}
         omit_rexw : boolean;
 {$endif x86_64}
       begin
         len:=0;
         codes:=@p^.code[0];
+        exists_vex := false;
+        exists_vex_extention := false;
+        exists_prefix_66 := false;
+        exists_prefix_F2 := false;
+        exists_prefix_F3 := false;
 {$ifdef x86_64}
         rex:=0;
         omit_rexw:=false;
@@ -1795,6 +1911,7 @@ implementation
             56,57,58,
             172,173,174 :
               inc(len,4);
+            60,61,62,63: ; // ignore vex-coded operand-idx
             208,209,210 :
               begin
                 case (oper[c-208]^.ot and OT_SIZE_MASK) of
@@ -1833,8 +1950,21 @@ implementation
             213,
             215,
             217,218: ;
-            219,220,241 :
-              inc(len);
+            219:
+              begin
+                inc(len);
+                exists_prefix_F2 := true;
+              end;
+            220:
+              begin
+                inc(len);
+                exists_prefix_F3 := true;
+              end;
+            241:
+              begin
+                inc(len);
+                exists_prefix_66 := true;
+              end;
             221:
 {$ifdef x86_64}
               omit_rexw:=true
@@ -1861,6 +1991,38 @@ implementation
 {$endif x86_64}
 
               end;
+            242: // VEX prefix for AVX (length = 2 or 3 bytes, dependens on REX.XBW or opcode-prefix ($0F38 or $0F3A))
+                 // =>> DEFAULT = 2 Bytes
+              begin
+                if not(exists_vex) then
+                begin
+                  inc(len, 2);
+                  exists_vex := true;
+                end;
+              end;
+            243: // REX.W = 1
+                 // =>> VEX prefix length = 3
+              begin
+                if not(exists_vex_extention) then
+                begin
+                  inc(len);
+                  exists_vex_extention := true;
+                end;
+              end;
+            244: ; // VEX length bit
+            247: inc(len); // operand 3 (ymmreg) encoded immediate byte (bit 4-7)
+            248: // VEX-Extention prefix $0F
+                 // ignore for calculating length
+                 ;
+            249, // VEX-Extention prefix $0F38
+            250: // VEX-Extention prefix $0F3A
+              begin
+                if not(exists_vex_extention) then
+                begin
+                  inc(len);
+                  exists_vex_extention := true;
+                end;
+              end;
             else
              InternalError(200603141);
           end;
@@ -1876,9 +2038,27 @@ implementation
             else
               rex:=rex and $F7;
           end;
-        if rex<>0 then
-          Inc(len);
+        if not(exists_vex) then 
+        begin
+          if rex<>0 then
+            Inc(len);
+        end;
 {$endif}
+        if exists_vex then
+        begin
+          if exists_prefix_66 then dec(len);
+          if exists_prefix_F2 then dec(len);
+          if exists_prefix_F3 then dec(len);
+
+  {$ifdef x86_64}
+          if not(exists_vex_extention) then
+          begin
+            // REX.WXB <> 0 =>> needed VEX-Extention
+            if rex and $0B <> 0 then inc(len);
+          end;
+  {$endif x86_64}
+
+        end;
         calcsize:=len;
       end;
 
@@ -1912,6 +2092,7 @@ implementation
        * \64, \65, \66 - select between \6[012] and \7[012] depending on 16/32 bit
        *                 assembly mode or the address-size override on the operand
        * \70, \71, \72 - a long relative operand, from operand 0, 1 or 2
+       * \74, \75, \76 - a vex-coded vector operand, from operand 0, 1 or 2
        * \1ab          - a ModRM, calculated on EA in operand a, with the spare
        *                 field the register value of operand b.
        * \2ab          - a ModRM, calculated on EA in operand a, with the spare
@@ -1937,6 +2118,16 @@ implementation
        * \334          - 0xF2 prefix for SSE instructions
        * \335          - Indicates 64-bit operand size with REX.W not necessary
        * \361          - 0x66 prefix for SSE instructions
+
+       * \362          - VEX prefix for AVX instructions
+       * \363          - VEX W1
+       * \364          - VEX Vector length 256
+       * \367          - operand 3 (ymmreg) encoded in bit 4-7 of the immediate byte
+
+       * \370          - VEX 0F-FLAG
+       * \371          - VEX 0F38-FLAG
+       * \372          - VEX 0F3A-FLAG
+
       }
 
       var
@@ -2047,6 +2238,13 @@ implementation
         data,s,opidx : longint;
         ea_data : ea;
         relsym : TObjSymbol;
+        needed_VEX_Extention: boolean;
+        needed_VEX: boolean;
+        opmode: integer;
+        i: integer;
+        insot: longint;
+        VEXvvvv: byte;
+        VEXmmmmm: byte;
       begin
         { safety check }
         if objdata.currobjsec.size<>longword(insoffset) then
@@ -2059,10 +2257,129 @@ implementation
         { Force word push/pop for registers }
         if (opsize=S_W) and ((codes[0]=#4) or (codes[0]=#6) or
             ((codes[0]=#1) and ((codes[2]=#5) or (codes[2]=#7)))) then
+        begin
+          bytes[0]:=$66;
+          objdata.writebytes(bytes,1);
+        end;
+
+        // needed VEX Prefix (for AVX etc.)
+
+        needed_VEX := false;
+        needed_VEX_Extention := false;
+        opmode   := -1;
+        VEXvvvv  := 0;
+        VEXmmmmm := 0;
+        repeat
+          c:=ord(codes^);
+          inc(codes);
+
+          case c of
+              0: break;
+              1,
+              2,
+              3: inc(codes,c);
+             60: opmode := 0;
+             61: opmode := 1;
+             62: opmode := 2;
+            219: VEXvvvv                := VEXvvvv  OR $02; // set SIMD-prefix $F3
+            220: VEXvvvv                := VEXvvvv  OR $03; // set SIMD-prefix $F2
+            241: VEXvvvv                := VEXvvvv  OR $01; // set SIMD-prefix $66
+            242: needed_VEX             := true;
+            243: begin
+                   needed_VEX_Extention := true;
+                   VEXvvvv              := VEXvvvv  OR (1 shl 7); // set REX.W
+                 end;
+            244: VEXvvvv                := VEXvvvv  OR $04; // vectorlength = 256 bits AND no scalar
+            248: VEXmmmmm               := VEXmmmmm OR $01; // set leading opcode byte $0F
+            249: begin
+                   needed_VEX_Extention := true;
+                   VEXmmmmm             := VEXmmmmm OR $02; // set leading opcode byte $0F38
+                 end;
+            250: begin
+                   needed_VEX_Extention := true;
+                   VEXmmmmm             := VEXmmmmm OR $03; // set leading opcode byte $0F3A
+                 end;
+
+          end;
+        until false;
+
+        if needed_VEX then
+        begin
+          if (opmode > ops) or
+             (opmode < -1) then
+          begin
+            Internalerror(777100);
+          end
+          else if opmode = -1 then
+          begin
+            VEXvvvv := VEXvvvv or ($0F shl 3); // set VEXvvvv bits (bits 6-3) to 1
+          end
+          else if oper[opmode]^.typ = top_reg then
+          begin
+            VEXvvvv := VEXvvvv or ((not(regval(oper[opmode]^.reg)) and $07) shl 3);
+
+            {$ifdef x86_64}
+              if rexbits(oper[opmode]^.reg) = 0 then VEXvvvv := VEXvvvv or (1 shl 6);
+            {$else}
+              VEXvvvv := VEXvvvv or (1 shl 6);
+            {$endif x86_64}
+          end
+          else Internalerror(777101);
+
+          if not(needed_VEX_Extention) then
+          begin
+            {$ifdef x86_64}
+              if rex and $0B <> 0 then needed_VEX_Extention := true;
+            {$endif x86_64}
+          end;
+
+          if needed_VEX_Extention then
+          begin
+            // VEX-Prefix-Length = 3 Bytes
+            bytes[0]:=$C4;
+            objdata.writebytes(bytes,1);
+
+            {$ifdef x86_64}
+              VEXmmmmm := VEXmmmmm or ((not(rex) and $07) shl 5);  // set REX.rxb
+            {$else}
+              VEXmmmmm := VEXmmmmm or (7 shl 5);  //
+            {$endif x86_64}
+
+              bytes[0] := VEXmmmmm;
+              objdata.writebytes(bytes,1);
+
+            {$ifdef x86_64}
+              VEXvvvv  := VEXvvvv OR ((rex and $08) shl 7);   // set REX.w
+            {$endif x86_64}
+            bytes[0] := VEXvvvv;
+            objdata.writebytes(bytes,1);
+          end
+          else
           begin
-            bytes[0]:=$66;
+            // VEX-Prefix-Length = 2 Bytes
+            bytes[0]:=$C5;
+            objdata.writebytes(bytes,1);
+
+            {$ifdef x86_64}
+              if rex and $04 = 0 then
+            {$endif x86_64}
+            begin
+              VEXvvvv := VEXvvvv or (1 shl 7);
+            end;
+
+            bytes[0] := VEXvvvv;
             objdata.writebytes(bytes,1);
           end;
+        end
+        else
+        begin
+          needed_VEX_Extention := false;
+          opmode := -1;
+        end;
+
+        { load data to write }
+        codes:=insentry^.code;
+
         repeat
           c:=ord(codes^);
           inc(codes);
@@ -2072,7 +2389,10 @@ implementation
             1,2,3 :
               begin
 {$ifdef x86_64}
-                maybewriterex;
+                if not(needed_VEX) then
+                begin
+                  maybewriterex;
+                end;
 {$endif x86_64}
                 objdata.writebytes(codes^,c);
                 inc(codes,c);
@@ -2113,7 +2433,10 @@ implementation
             8,9,10 :
               begin
 {$ifdef x86_64}
-                maybewriterex;
+                if not(needed_VEX) then
+                begin
+                  maybewriterex;
+                end;
 {$endif x86_64}
                 bytes[0]:=ord(codes^)+regval(oper[c-8]^.reg);
                 inc(codes);
@@ -2242,6 +2565,8 @@ implementation
                 else
                  objdata_writereloc(currval-insend,4,nil,currabsreloc32)
               end;
+            60,61,62 : ; // 074..076 - vex-coded vector operand
+                         // ignore
             172,173,174 :  // 0254..0256 - dword implicitly sign-extended to 64-bit (x86_64 only)
               begin
                 getvalsym(c-172);
@@ -2292,10 +2617,14 @@ implementation
             211,
             213 : {no action needed};
 
-            212, 241 :
+            212,
+            241:
               begin
-                bytes[0]:=$66;
-                objdata.writebytes(bytes,1);
+                if not(needed_VEX) then
+                begin
+                  bytes[0]:=$66;
+                  objdata.writebytes(bytes,1);
+                end;
               end;
             214 :
               begin
@@ -2305,13 +2634,19 @@ implementation
               end;
             219 :
               begin
-                bytes[0]:=$f3;
-                objdata.writebytes(bytes,1);
+                if not(needed_VEX) then
+                begin
+                  bytes[0]:=$f3;
+                  objdata.writebytes(bytes,1);
+                end;
               end;
             220 :
               begin
-                bytes[0]:=$f2;
-                objdata.writebytes(bytes,1);
+                if not(needed_VEX) then
+                begin
+                  bytes[0]:=$f2;
+                  objdata.writebytes(bytes,1);
+                end;
               end;
             221:
               ;
@@ -2322,6 +2657,29 @@ implementation
                 { these are dissambler hints or 32 bit prefixes which
                   are not needed }
               end;
+            242..244: ; // VEX flags =>> nothing todo
+                 247: begin
+                        if needed_VEX then
+                        begin
+                          if ops = 4 then
+                          begin
+                            if (oper[3]^.typ=top_reg) then
+                            begin
+                              if (oper[3]^.ot and otf_reg_xmm <> 0) or
+                                 (oper[3]^.ot and otf_reg_ymm <> 0) then
+                              begin
+                                bytes[0] := ((getsupreg(oper[3]^.reg) and 15) shl 4);
+                                objdata.writebytes(bytes,1);
+                              end
+                              else Internalerror(777102);
+                            end
+                            else Internalerror(777103);
+                          end
+                          else Internalerror(777104);
+                        end
+                        else Internalerror(777105);
+                      end;
+            248..250: ; // VEX flags =>> nothing todo
             31,
             48,49,50 :
               begin
@@ -2331,8 +2689,11 @@ implementation
               begin
                 { rex should be written at this point }
 {$ifdef x86_64}
-                if (rex<>0) and not(rexwritten) then
-                  internalerror(200603191);
+                if not(needed_VEX) then
+                begin
+                  if (rex<>0) and not(rexwritten) then
+                    internalerror(200603191);
+                end;
 {$endif x86_64}
                 if (c>=64) and (c<=151) then  // 0100..0227
                  begin
@@ -2597,11 +2958,169 @@ implementation
       end;
 
 
+    procedure BuildInsTabMemRefSizeInfoCache;
+    var
+      AsmOp: TasmOp;
+      i,j: longint;
+      insentry  : PInsEntry;
+      MRefInfo: TMemRefSizeInfo;
+      SConstInfo: TConstSizeInfo;
+      actRegSize: int64;
+      RegSize: int64;
+      MemSize: int64;
+      IsRegSizeMemSize: boolean;
+      ExistsRegMem: 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 := msiUnkown;
+          RegSize := 0;
+          IsRegSizeMemSize := true;
+          ExistsRegMem     := false;
+
+          insentry:=@instab[i];
+          while (insentry^.opcode=AsmOp) do
+          begin
+            MRefInfo         := msiUnkown;
+            actRegSize       := -1;
+
+            for j := 0 to insentry^.ops -1 do
+            begin
+              if ((insentry^.optypes[j] and OT_MEMORY) <> 0) then
+              begin
+                if (insentry^.optypes[j] and OT_REGISTER) = OT_REGISTER then
+                begin
+                  MRefInfo := msiUnkown;
+
+                  actRegSize := insentry^.optypes[j] and OT_SIZE_MASK;
+                  if actRegSize = 0 then
+                  begin
+                    case insentry^.optypes[j] and (OT_XMMREG OR OT_YMMREG) of
+                      OT_XMMREG: begin
+                                   actRegSize := OT_BITS128;
+                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
+                                 end;
+                      OT_YMMREG: begin
+                                   actRegSize := OT_BITS256;
+                                   InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
+                                 end;
+                    end;
+                  end;
+
+                  if RegSize = 0 then RegSize := actRegSize
+                   else if actRegSize <> RegSize then RegSize := -1;
+                end
+                else
+                begin
+                  MemSize := insentry^.optypes[j] and OT_SIZE_MASK;
+                  case MemSize of
+                             0: case insentry^.optypes[j] and (OT_MMXRM OR OT_XMMRM OR OT_YMMRM OR OT_REGISTER) of
+                                  OT_MMXRM: begin
+                                              MRefInfo := msiMem64;
+                                              MemSize  := OT_BITS64;
+                                            end;
+                                  OT_XMMRM: begin
+                                              MRefInfo := msiMem128;
+                                              MemSize  := OT_BITS128;
+                                              InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
+                                            end;
+                                  OT_YMMRM: begin
+                                              MRefInfo := msiMem256;
+                                              MemSize  := OT_BITS256;
+                                              InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true;
+                                            end;
+                                       else MRefInfo := msiUnkown;
+                                end;
+                      OT_BITS8: MRefInfo := msiMem8;
+                     OT_BITS16: MRefInfo := msiMem16;
+                     OT_BITS32: MRefInfo := msiMem32;
+                     OT_BITS64: MRefInfo := msiMem64;
+                    OT_BITS128: MRefInfo := msiMem128;
+                    OT_BITS256: MRefInfo := msiMem256;
+                           else MRefInfo := msiMultiple;
+                  end;
+
+                  if MRefInfo <> msiUnkown then
+                  begin
+                    if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiUnkown then
+                    begin
+                      InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := MRefInfo;
+                    end
+                    else if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize <> MRefInfo then
+                    begin
+                      InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMultiple;
+                    end;
+                  end;
+                end;
+              end
+              else if (insentry^.optypes[j] and OT_IMMEDIATE) = OT_IMMEDIATE then
+              begin
+                case insentry^.optypes[j] and OT_SIZE_MASK 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 = csiUnkown then
+                begin
+                  InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := SConstInfo;
+                end
+                else if InsTabMemRefSizeInfoCache^[AsmOp].ConstSize <> SConstInfo then
+                begin
+                  InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := csiMultiple;
+                end;
+              end;
+            end;
+
+            if actRegSize < 0 then RegSize := -1;
+
+            if RegSize > 0 then
+            begin
+              IsRegSizeMemSize := IsRegSizeMemSize and ((RegSize > 0) and (RegSize = MemSize));
+              ExistsRegMem     := true;
+            end;
+
+            inc(insentry);
+          end;
+
+          if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiMultiple then
+          begin
+            if IsRegSizeMemSize and ExistsRegMem then InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegSize;
+          end;
+        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 := msiUnkown;
+        end;
+
+      end;
+    end;
+
     procedure InitAsm;
       begin
         build_spilling_operation_type_table;
         if not assigned(instabcache) then
           BuildInsTabCache;
+
+        if not assigned(InsTabMemRefSizeInfoCache) then
+          BuildInsTabMemRefSizeInfoCache;
       end;
 
 
@@ -2617,6 +3136,12 @@ implementation
             dispose(instabcache);
             instabcache:=nil;
           end;
+
+        if assigned(InsTabMemRefSizeInfoCache) then
+        begin
+          dispose(InsTabMemRefSizeInfoCache);
+          InsTabMemRefSizeInfoCache:=nil;
+        end;
       end;
 
 
diff --git a/compiler/x86/agx86att.pas b/compiler/x86/agx86att.pas
index 55b2a949f2..c4214c2497 100644
--- a/compiler/x86/agx86att.pas
+++ b/compiler/x86/agx86att.pas
@@ -235,6 +235,7 @@ interface
        calljmp  : boolean;
        need_second_mov : boolean;
        i        : integer;
+       sreg     : string;
       begin
         if hp.typ <> ait_instruction then
           exit;
@@ -246,6 +247,30 @@ interface
           the fix consists of simply setting only the 4-byte register
           as the upper 4-bytes will be zeroed at the same time. }
         need_second_mov:=false;
+
+        // BUGFIX GAS-assembler
+        // Intel "Intel 64 and IA-32 Architectures Software Developers manual 12/2011
+        // Intel:       VCVTDQ2PD  YMMREG, YMMREG/mem128 ((intel syntax))
+        // GAS:         VCVTDQ2PD  YMMREG, XMMREG/mem128 ((intel syntax))
+        if (op = A_VCVTDQ2PD) and
+           (taicpu(hp).ops = 2) and
+           (taicpu(hp).oper[0]^.typ = top_reg) and
+           (taicpu(hp).oper[1]^.typ = top_reg) then
+        begin
+          if ((taicpu(hp).oper[0]^.ot and OT_YMMREG) = OT_YMMREG) and
+             ((taicpu(hp).oper[1]^.ot and OT_YMMREG) = OT_YMMREG) then
+          begin
+            // change registertype in oper[0] from OT_YMMREG to OT_XMMREG
+            taicpu(hp).oper[0]^.ot := taicpu(hp).oper[0]^.ot and not(OT_YMMREG) or OT_XMMREG;
+
+            sreg := gas_regname(taicpu(hp).oper[0]^.reg);
+            if (copy(sreg, 1, 2) = '%y') or
+               (copy(sreg, 1, 2) = '%Y') then
+            begin
+              taicpu(hp).oper[0]^.reg := gas_regnum_search('%x' + copy(sreg, 3, length(sreg) - 2));
+            end;
+          end;
+        end;
 {$ifdef x86_64}
         if (op=A_MOV) and (taicpu(hp).opsize=S_Q) and
            (taicpu(hp).oper[0]^.typ = top_const) then
@@ -292,7 +317,38 @@ interface
                (taicpu(hp).oper[0]^.typ=top_reg) and
                (getregtype(taicpu(hp).oper[0]^.reg)=R_FPUREGISTER)
               ) then
-          owner.AsmWrite(gas_opsize2str[taicpu(hp).opsize]);
+        begin
+          if gas_needsuffix[op] = AttSufMM then
+          begin
+            for i:=0 to taicpu(hp).ops-1 do
+            begin
+
+              if (taicpu(hp).oper[i]^.typ = top_ref) then
+              begin
+                case taicpu(hp).oper[i]^.ot and OT_SIZE_MASK of
+                   OT_BITS32: begin
+                                owner.AsmWrite(gas_opsize2str[S_L]);
+                                break;
+                              end;
+                   OT_BITS64: begin
+                                owner.AsmWrite(gas_opsize2str[S_Q]);
+                                break;
+                              end;
+                  OT_BITS128: begin
+                                owner.AsmWrite(gas_opsize2str[S_XMM]);
+                                break;
+                              end;
+                  OT_BITS256: begin
+                                owner.AsmWrite(gas_opsize2str[S_YMM]);
+                                break;
+                              end;
+                end;
+              end;
+            end;
+          end
+          else owner.AsmWrite(gas_opsize2str[taicpu(hp).opsize]);
+        end;
+
         { process operands }
         if taicpu(hp).ops<>0 then
           begin
diff --git a/compiler/x86/agx86int.pas b/compiler/x86/agx86int.pas
index be4cdbe50f..52774e936d 100644
--- a/compiler/x86/agx86int.pas
+++ b/compiler/x86/agx86int.pas
@@ -336,6 +336,8 @@ implementation
                              AsmWrite('dword ptr ')
                             else
                              AsmWrite('word ptr ');
+                     S_XMM: AsmWrite('xmmword ptr ');
+                     S_YMM: AsmWrite('ymmword ptr ');
 {$ifdef x86_64}
                      S_BQ : if dest then
                              AsmWrite('qword ptr ')
@@ -349,7 +351,6 @@ implementation
                              AsmWrite('qword ptr ')
                             else
                              AsmWrite('dword ptr ');
-                     S_XMM: AsmWrite('xmmword ptr ');
 
 {$endif x86_64}
                      end;
diff --git a/compiler/x86/cgx86.pas b/compiler/x86/cgx86.pas
index e9d4483879..f6f58dcf83 100644
--- a/compiler/x86/cgx86.pas
+++ b/compiler/x86/cgx86.pas
@@ -134,16 +134,16 @@ unit cgx86;
    const
 {$ifdef x86_64}
       TCGSize2OpSize: Array[tcgsize] of topsize =
-        (S_NO,S_B,S_W,S_L,S_Q,S_T,S_B,S_W,S_L,S_Q,S_Q,
+        (S_NO,S_B,S_W,S_L,S_Q,S_XMM,S_B,S_W,S_L,S_Q,S_XMM,
          S_FS,S_FL,S_FX,S_IQ,S_FXX,
-         S_NO,S_NO,S_NO,S_MD,S_T,
-         S_NO,S_NO,S_NO,S_NO,S_T);
+         S_NO,S_NO,S_NO,S_MD,S_XMM,S_YMM,
+         S_NO,S_NO,S_NO,S_NO,S_XMM,S_YMM);
 {$else x86_64}
       TCGSize2OpSize: Array[tcgsize] of topsize =
         (S_NO,S_B,S_W,S_L,S_L,S_T,S_B,S_W,S_L,S_L,S_L,
          S_FS,S_FL,S_FX,S_IQ,S_FXX,
-         S_NO,S_NO,S_NO,S_MD,S_T,
-         S_NO,S_NO,S_NO,S_NO,S_T);
+         S_NO,S_NO,S_NO,S_MD,S_XMM,S_YMM,
+         S_NO,S_NO,S_NO,S_NO,S_XMM,S_YMM);
 {$endif x86_64}
 
 {$ifndef NOTARGETWIN}
diff --git a/compiler/x86/cpubase.pas b/compiler/x86/cpubase.pas
index 056e571cf7..a17048ae82 100644
--- a/compiler/x86/cpubase.pas
+++ b/compiler/x86/cpubase.pas
@@ -52,7 +52,7 @@ uses
 {$endif x86_64}
 
       { This should define the array of instructions as string }
-      op2strtable=array[tasmop] of string[15];
+        op2strtable=array[tasmop] of string[16];
 
     const
       { First value of opcode enumeration }
@@ -325,7 +325,9 @@ implementation
                 internalerror(2009071902);
             end;
           OS_M128,OS_MS128:
-            cgsize2subreg:=R_SUBMMWHOLE;
+            cgsize2subreg:=R_SUBMMX;
+          OS_M256,OS_MS256:
+            cgsize2subreg:=R_SUBMMY;
           else
             internalerror(200301231);
         end;
@@ -334,7 +336,7 @@ implementation
 
     function reg_cgsize(const reg: tregister): tcgsize;
       const subreg2cgsize:array[Tsubregister] of Tcgsize =
-            (OS_NO,OS_8,OS_8,OS_16,OS_32,OS_64,OS_NO,OS_NO,OS_NO,OS_F32,OS_F64,OS_M128);
+            (OS_NO,OS_8,OS_8,OS_16,OS_32,OS_64,OS_NO,OS_NO,OS_NO,OS_F32,OS_F64,OS_NO,OS_M128,OS_M256);
       begin
         case getregtype(reg) of
           R_INTREGISTER :
@@ -365,7 +367,7 @@ implementation
     function reg2opsize(r:Tregister):topsize;
       const
         subreg2opsize : array[tsubregister] of topsize =
-          (S_NO,S_B,S_B,S_W,S_L,S_Q,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO);
+          (S_NO,S_B,S_B,S_W,S_L,S_Q,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO);
       begin
         reg2opsize:=S_L;
         case getregtype(r) of
@@ -456,7 +458,7 @@ implementation
         hr:=r;
         case getsubreg(hr) of
           R_SUBMMS,R_SUBMMD,R_SUBMMWHOLE:
-            setsubreg(hr,R_SUBNONE);
+            setsubreg(hr,R_SUBMMX);
         end;
         result:=findreg_by_number_table(hr,regnumber_index);
       end;
diff --git a/compiler/x86/itcpugas.pas b/compiler/x86/itcpugas.pas
index 4280245f4d..014101337e 100644
--- a/compiler/x86/itcpugas.pas
+++ b/compiler/x86/itcpugas.pas
@@ -29,7 +29,7 @@ interface
       cgbase,cpubase;
 
     type
-      TAttSuffix = (AttSufNONE,AttSufINT,AttSufFPU,AttSufFPUint,AttSufINTdual);
+      TAttSuffix = (AttSufNONE,AttSufINT,AttSufFPU,AttSufFPUint,AttSufINTdual,AttSufMM);
 
     const
 {$ifdef x86_64}
@@ -50,7 +50,8 @@ interface
        'd',
        '','','',
        't',
-       ''
+        'x',
+        'y'
      );
      { suffix-to-opsize conversion tables, used in asmreadrer }
      { !! S_LQ excluded: movzlq does not exist, movslq is processed
@@ -76,7 +77,8 @@ interface
        'd',
        '','','',
        't',
-       ''
+        'x',
+        'y'   
      );
      { suffix-to-opsize conversion tables, used in asmreadrer }
      att_sizesuffixstr : array[0..9] of string[2] = (
diff --git a/compiler/x86/itx86int.pas b/compiler/x86/itx86int.pas
index 182938678d..1199159576 100644
--- a/compiler/x86/itx86int.pas
+++ b/compiler/x86/itx86int.pas
@@ -58,20 +58,27 @@ implementation
     {$endif x86_64}
 
 
-    function findreg_by_intname(const s:string):byte;
+    function findreg_by_intname(const s:string):integer;
       var
-        i,p : tregisterindex;
+        i,p : integer;
+        s1: string;
+
+        l,r,m: integer;
       begin
         {Binary search.}
         p:=0;
-        i:=regnumber_count_bsstart;
-        repeat
-          if (p+i<=high(tregisterindex)) and (int_regname_table[int_regname_index[p+i]]<=s) then
-            p:=p+i;
-          i:=i shr 1;
-        until i=0;
-        if int_regname_table[int_regname_index[p]]=s then
-          findreg_by_intname:=int_regname_index[p]
+        i := (high(tregisterindex) + 1) shr 1;
+           l := 0;
+           r := high(tregisterindex) + 1;
+           while l < r do
+           begin
+              m := (l + r) div 2;
+              if int_regname_table[int_regname_index[m]] < s then l := m + 1
+              else r := m;
+           end;
+
+        if int_regname_table[int_regname_index[r]]=s then
+          findreg_by_intname:=int_regname_index[r]
         else
           findreg_by_intname:=0;
       end;
diff --git a/compiler/x86/rax86.pas b/compiler/x86/rax86.pas
index 51afa60ac5..be4852ecc5 100644
--- a/compiler/x86/rax86.pas
+++ b/compiler/x86/rax86.pas
@@ -186,6 +186,12 @@ begin
   inherited SetSize(_size,force);
   { OS_64 will be set to S_L and be fixed later
     in SetCorrectSize }
+
+  // multimedia register
+  case _size of
+    16: size := OS_M128;
+    32: size := OS_M256;
+  end;
   opsize:=TCGSize2Opsize[size];
 end;
 
@@ -207,6 +213,16 @@ begin
         OS_64 : opsize:=S_IQ;
       end;
     end
+  else if gas_needsuffix[opcode]=AttSufMM then
+  begin
+    if (opr.typ=OPR_Reference) then
+    begin
+      case size of
+        OS_32 : size := OS_M32;
+        OS_64 : size := OS_M64;
+      end;
+    end;
+  end
   else
     begin
       if size=OS_64 then
@@ -281,7 +297,73 @@ var
   operand2,i : longint;
   s : tasmsymbol;
   so : aint;
+  ExistsMemRefNoSize: boolean;
 begin
+  ExistsMemRefNoSize := false;
+  for i := 1 to ops do
+  begin
+    if (tx86operand(operands[i]).opsize = S_NO) and
+       (operands[i].Opr.Typ in [OPR_REFERENCE]) then
+    begin
+      ExistsMemRefNoSize := true;
+    end;
+  end;
+
+  if ExistsMemRefNoSize then
+  begin
+    for i := 1 to ops do
+    begin
+      if (tx86operand(operands[i]).opsize = S_NO) then
+      begin
+        case operands[i].Opr.Typ of
+          OPR_REFERENCE:
+                case MemRefInfo(opcode).MemRefSize of
+                    msiMem8: begin
+                                tx86operand(operands[i]).opsize := S_B;
+                                tx86operand(operands[i]).size   := OS_8;
+                              end;
+                   msiMem16: begin
+                               tx86operand(operands[i]).opsize := S_W;
+                               tx86operand(operands[i]).size   := OS_16;
+                             end;
+                   msiMem32: begin
+                               tx86operand(operands[i]).opsize := S_L;
+                               tx86operand(operands[i]).size   := OS_32;
+                             end;
+                   msiMem64: begin
+                               tx86operand(operands[i]).opsize := S_Q;
+                               tx86operand(operands[i]).size   := OS_M64;
+                             end;
+                  msiMem128: begin
+                               tx86operand(operands[i]).opsize := S_XMM;
+                               tx86operand(operands[i]).size   := OS_M128;
+                             end;
+                  msiMem256: begin
+                               tx86operand(operands[i]).opsize := S_YMM;
+                               tx86operand(operands[i]).size   := OS_M256;
+                             end;
+                end;
+          OPR_CONSTANT:
+                case MemRefInfo(opcode).ConstSize of
+                   csiMem8: begin
+                              tx86operand(operands[i]).opsize := S_B;
+                              tx86operand(operands[i]).size   := OS_8;
+                            end;
+                  csiMem16: begin
+                              tx86operand(operands[i]).opsize := S_W;
+                              tx86operand(operands[i]).size   := OS_16;
+                            end;
+                  csiMem32: begin
+                              tx86operand(operands[i]).opsize := S_L;
+                              tx86operand(operands[i]).size   := OS_32;
+                            end;
+                end;
+        end;
+      end;
+    end;
+  end;
+
+
   for i:=1 to ops do
     begin
       operands[i].SetCorrectSize(opcode);
@@ -311,8 +393,24 @@ begin
                        begin
                          if ((opcode<>A_MOVD) and
                              (opcode<>A_CVTSI2SS)) then
-                           tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize;
-                       end
+                      begin
+                        //tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize;
+
+                        // torsten - 31.01.2012
+                        // old: xmm/ymm-register operands have a opsize = "S_NO"
+                        // new: xmm/ymm-register operands have a opsize = "S_XMM/S_YMM"
+
+                        // any SSE- and AVX-opcodes have mixed operand sizes (e.g. cvtsd2ss xmmreg, xmmreg/m32)
+                        // in this case is we need the old handling ("S_NO")
+                        // =>> ignore
+                        if (tx86operand(operands[operand2]).opsize <> S_XMM) and
+                           (tx86operand(operands[operand2]).opsize <> S_YMM) then
+                        begin
+                          tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize;
+                        end
+                        else tx86operand(operands[operand2]).opsize := S_NO;
+                      end;
+                    end
                      else
                       begin
                         { if no register then take the opsize (which is available with ATT),
@@ -417,11 +515,30 @@ begin
           A_OUT :
             opsize:=tx86operand(operands[1]).opsize;
           else
-            opsize:=tx86operand(operands[2]).opsize;
+          begin
+            // opsize:=tx86operand(operands[2]).opsize;
+
+            // torsten - 31.01.2012
+            // old: xmm/ymm-register operands have a opsize = "S_NO"
+            // new: xmm/ymm-register operands have a opsize = "S_XMM/S_YMM"
+
+            // any SSE- and AVX-opcodes have mixed operand sizes (e.g. cvtsd2ss xmmreg, xmmreg/m32)
+            // in this case is we need the old handling ("S_NO")
+            // =>> ignore
+            if (tx86operand(operands[2]).opsize <> S_XMM) and
+               (tx86operand(operands[2]).opsize <> S_YMM) then
+            begin
+              opsize:=tx86operand(operands[2]).opsize;
+            end;
+
+          end;
         end;
       end;
-    3 :
-      opsize:=tx86operand(operands[3]).opsize;
+    3,4 :
+      begin
+          opsize:=tx86operand(operands[ops]).opsize;
+      end;
+
   end;
 end;
 
@@ -736,7 +853,7 @@ begin
                      asize:=OT_BITS8;
                    OS_16,OS_S16 :
                      asize:=OT_BITS16;
-                   OS_32,OS_S32,OS_F32 :
+                   OS_32,OS_S32,OS_F32,OS_M32 :
                      asize:=OT_BITS32;
                    OS_64,OS_S64:
                      begin
@@ -752,10 +869,14 @@ begin
 {$endif i386}
                          ;
                      end;
-                   OS_F64,OS_C64 :
+                   OS_F64,OS_C64, OS_M64 :
                      asize:=OT_BITS64;
                    OS_F80 :
                      asize:=OT_BITS80;
+                   OS_128,OS_M128,OS_MS128:
+                     asize := OT_BITS128;
+                   OS_M256,OS_MS256:
+                     asize := OT_BITS256;
                  end;
                if asize<>0 then
                  ai.oper[i-1]^.ot:=(ai.oper[i-1]^.ot and not OT_SIZE_MASK) or asize;
diff --git a/compiler/x86/rax86int.pas b/compiler/x86/rax86int.pas
index e5536a1083..8a009823ea 100644
--- a/compiler/x86/rax86int.pas
+++ b/compiler/x86/rax86int.pas
@@ -42,7 +42,7 @@ Unit Rax86int;
        {------------------ Assembler directives --------------------}
       AS_ALIGN,AS_DB,AS_DW,AS_DD,AS_DQ,AS_END,
        {------------------ Assembler Operators  --------------------}
-      AS_BYTE,AS_WORD,AS_DWORD,AS_QWORD,AS_TBYTE,AS_DQWORD,AS_NEAR,AS_FAR,
+      AS_BYTE,AS_WORD,AS_DWORD,AS_QWORD,AS_TBYTE,AS_DQWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_NEAR,AS_FAR,
       AS_HIGH,AS_LOW,AS_OFFSET,AS_SIZEOF,AS_VMTOFFSET,AS_SEG,AS_TYPE,AS_PTR,AS_MOD,AS_SHL,AS_SHR,AS_NOT,
       AS_AND,AS_OR,AS_XOR);
 
@@ -114,13 +114,13 @@ Unit Rax86int;
        { problems with shl,shr,not,and,or and xor, they are }
        { context sensitive.                                 }
        _asmoperators : array[0.._count_asmoperators] of tasmkeyword = (
-        'BYTE','WORD','DWORD','QWORD','TBYTE','DQWORD','NEAR','FAR','HIGH',
+        'BYTE','WORD','DWORD','QWORD','TBYTE','DQWORD','OWORD','XMMWORD','YWORD','YMMWORD','NEAR','FAR','HIGH',
         'LOW','OFFSET','SIZEOF','VMTOFFSET','SEG','TYPE','PTR','MOD','SHL','SHR','NOT','AND',
         'OR','XOR');
 
       token2str : array[tasmtoken] of string[10] = (
         '','Label','LLabel','String','Integer',
-        ',','[',']','(',
+        ',',',',',',',',',','[',']','(',
         ')',':','.','+','-','*',
         ';','identifier','register','opcode','/',
         '','','','','','END',
@@ -729,7 +729,7 @@ Unit Rax86int;
         while (actasmtoken=AS_DOT) do
          begin
            Consume(AS_DOT);
-           if actasmtoken in [AS_BYTE,AS_ID,AS_WORD,AS_DWORD,AS_QWORD,AS_REGISTER] then
+           if actasmtoken in [AS_BYTE,AS_ID,AS_WORD,AS_DWORD,AS_QWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_REGISTER] then
              begin
                s:=s+'.'+actasmpattern;
                consume(actasmtoken);
@@ -1819,7 +1819,11 @@ Unit Rax86int;
             AS_WORD,
             AS_TBYTE,
             AS_DQWORD,
-            AS_QWORD :
+            AS_QWORD,
+            AS_OWORD,
+            AS_XMMWORD,
+            AS_YWORD,
+            AS_YMMWORD:
               begin
                 { Type specifier }
                 oper.hastype:=true;
@@ -1831,6 +1835,10 @@ Unit Rax86int;
                   AS_QWORD : oper.typesize:=8;
                   AS_DQWORD : oper.typesize:=16;
                   AS_TBYTE : oper.typesize:=10;
+                  AS_OWORD,                     
+                  AS_XMMWORD: oper.typesize:=16; 
+                  AS_YWORD,                     
+                  AS_YMMWORD: oper.typesize:=32;
                   else
                     internalerror(2010061101);
                 end;
diff --git a/compiler/x86/x86ins.dat b/compiler/x86/x86ins.dat
index 0192216535..86bf90f877 100644
--- a/compiler/x86/x86ins.dat
+++ b/compiler/x86/x86ins.dat
@@ -10,6 +10,7 @@
 ; arguments   bytes   flags
 ;
 
+
 [NONE]
 (Ch_None, Ch_None, Ch_None)
 void                  void                            none
@@ -1458,7 +1459,7 @@ void                  \326\1\x9D                      X86_64
 [POR]
 (Ch_All, Ch_None, Ch_None)
 mmxreg,mmxrm          \2\x0F\xEB\110                  PENT,MMX,SM
-xmmreg,xmmreg         \361\2\x0F\xEB\110              WILLAMETTE,SSE2,SM
+xmmreg,xmmrm          \361\2\x0F\xEB\110              WILLAMETTE,SSE2,SM
 
 [PREFETCH,prefetchX]
 (Ch_All, Ch_None, Ch_None)
@@ -2209,32 +2210,31 @@ xmmreg,xmmrm          \2\x0F\x2F\110                  KATMAI,SSE
 
 [CVTPI2PS]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,mem            \331\2\x0F\x2A\110              KATMAI,SSE,MMX
-xmmreg,mmxreg         \331\2\x0F\x2A\110             KATMAI,SSE,MMX
+xmmreg,mmxrm         \331\2\x0F\x2A\110             KATMAI,SSE,MMX
 
 [CVTPS2PI]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-mmxreg,mem            \331\2\x0F\x2D\110              KATMAI,SSE,MMX
+mmxreg,mem64          \331\2\x0F\x2D\110              KATMAI,SSE,MMX
 mmxreg,xmmreg         \331\2\x0F\x2D\110              KATMAI,SSE,MMX
 
-[CVTSI2SS,cvtsi2ssX]
+[CVTSI2SS,cvtsi2ssM]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,mem            \333\321\2\x0F\x2A\110      KATMAI,SSE
-xmmreg,reg32|64       \333\321\2\x0F\x2A\110      KATMAI,SSE
+xmmreg,rm32           \333\321\2\x0F\x2A\110      KATMAI,SSE
+xmmreg,rm64           \333\321\2\x0F\x2A\110      KATMAI,SSE,X86_64,SI
 
 [CVTSS2SI,cvtss2siX]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-reg32|64,mem          \333\320\2\x0F\x2D\110          KATMAI,SSE
+reg32|64,mem32	      \333\320\2\x0F\x2D\110          KATMAI,SSE
 reg32|64,xmmreg       \333\320\2\x0F\x2D\110          KATMAI,SSE
 
 [CVTTPS2PI]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-mmxreg,mem            \331\2\x0F\x2C\110              KATMAI,SSE,MMX
+mmxreg,mem64          \331\2\x0F\x2C\110              KATMAI,SSE,MMX
 mmxreg,xmmreg         \331\2\x0F\x2C\110              KATMAI,SSE,MMX
 
 [CVTTSS2SI,cvttss2siX]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-reg32|64,mem          \333\320\2\x0F\x2C\110          KATMAI,SSE
+reg32|64,mem32        \333\320\2\x0F\x2C\110          KATMAI,SSE
 reg32|64,xmmreg       \333\320\2\x0F\x2C\110          KATMAI,SSE
 
 [DIVPS]
@@ -2710,7 +2710,8 @@ xmmreg,xmmrm            \361\2\x0F\x2F\110              WILLAMETTE,SSE2
 
 [CVTDQ2PD]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,xmmrm            \333\2\x0F\xE6\110              WILLAMETTE,SSE2
+xmmreg,xmmreg            \333\2\x0F\xE6\110              WILLAMETTE,SSE2
+xmmreg,mem64             \333\2\x0F\xE6\110              WILLAMETTE,SSE2
 
 [CVTDQ2PS]
 (Ch_Wop2, Ch_Rop1, Ch_None)
@@ -2738,30 +2739,34 @@ xmmreg,xmmrm            \361\2\x0F\x5B\110              WILLAMETTE,SSE2,SM
 
 [CVTPS2PD]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,xmmrm            \2\x0F\x5A\110                WILLAMETTE,SSE2 ;,SQ
+xmmreg,xmmreg            \2\x0F\x5A\110                WILLAMETTE,SSE2 ;,SQ
+xmmreg,mem64             \2\x0F\x5A\110                WILLAMETTE,SSE2 ;,SQ
 
 [CVTSD2SI,cvtsd2siX]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-reg32|64,xmmreg         \334\320\2\x0F\x2D\110        WILLAMETTE,SSE2
-reg32|64,mem            \334\320\2\x0F\x2D\110        WILLAMETTE,SSE2
+reg32,xmmreg 	        \334\2\x0F\x2D\110        WILLAMETTE,SSE2
+reg32,mem64          	\334\2\x0F\x2D\110        WILLAMETTE,SSE2
+reg64,xmmreg 	        \334\320\2\x0F\x2D\110        WILLAMETTE,SSE2,X86_64
+reg64,mem64 	        \334\320\2\x0F\x2D\110        WILLAMETTE,SSE2,X86_64
 
 [CVTSD2SS]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,xmmrm            \334\2\x0F\x5A\110              WILLAMETTE,SSE2 ;,SQ
+xmmreg,xmmreg           \334\2\x0F\x5A\110              WILLAMETTE,SSE2 ;,SQ
+xmmreg,mem64            \334\2\x0F\x5A\110              WILLAMETTE,SSE2 ;,SQ
 
-[CVTSI2SD,cvtsi2sdX]
+[CVTSI2SD,cvtsi2sdM]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,reg32|64         \334\321\2\x0F\x2A\110        WILLAMETTE,SSE2
-xmmreg,mem              \334\321\2\x0F\x2A\110        WILLAMETTE,SSE2
+xmmreg,rm32             \334\2\x0F\x2A\110        	WILLAMETTE,SSE2
+xmmreg,rm64             \326\334\321\2\x0F\x2A\110      WILLAMETTE,SSE2,X86_64,SI
 
 [CVTSS2SD]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-xmmreg,xmmrm            \333\2\x0F\x5A\110            WILLAMETTE,SSE2 ;,SD
+xmmreg,xmmreg            \333\2\x0F\x5A\110            WILLAMETTE,SSE2 ;,SD
+xmmreg,mem32             \333\2\x0F\x5A\110            WILLAMETTE,SSE2 ;,SD
 
 [CVTTPD2PI]
 (Ch_Wop2, Ch_Rop1, Ch_None)
-mmxreg,xmmreg           \361\2\x0F\x2C\110              WILLAMETTE,SSE2
-mmxreg,mem              \361\2\x0F\x2C\110              WILLAMETTE,SSE2
+mmxreg,xmmrm            \361\2\x0F\x2C\110              WILLAMETTE,SSE2
 
 [CVTTPD2DQ]
 (Ch_Wop2, Ch_Rop1, Ch_None)
@@ -2774,7 +2779,7 @@ xmmreg,xmmrm            \333\2\x0F\x5B\110              WILLAMETTE,SSE2,SM
 [CVTTSD2SI,cvttsd2siX]
 (Ch_Wop2, Ch_Rop1, Ch_None)
 reg32|64,xmmreg         \334\320\2\x0F\x2C\110        WILLAMETTE,SSE2
-reg32|64,mem            \334\320\2\x0F\x2C\110        WILLAMETTE,SSE2
+reg32|64,mem64          \334\320\2\x0F\x2C\110        WILLAMETTE,SSE2
 
 [DIVPD]
 (Ch_Mop2, Ch_Rop1, Ch_None)
@@ -3441,3 +3446,1230 @@ void                   \326\1\xAD                                    X86_64
 [CMPSQ]
 (Ch_All, Ch_None, Ch_None)
 void                   \326\1\xA7                                    X86_64
+
+;*******************************************************************************
+;****** AVX I ******************************************************************
+;*******************************************************************************
+
+
+[VADDPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x58\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x58\75\120        AVX,SANDYBRIDGE
+
+[VADDPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x58\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x58\75\120            AVX,SANDYBRIDGE
+
+[VADDSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x58\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x58\75\120            AVX,SANDYBRIDGE
+
+[VADDSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x58\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x58\75\120            AVX,SANDYBRIDGE
+
+[VADDSUBPD]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\xD0\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD0\75\120            AVX,SANDYBRIDGE
+
+[VADDSUBPS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,ymmrm                  \334\362\364\370\1\xD0\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \334\362\370\1\xD0\75\120            AVX,SANDYBRIDGE
+
+[VAESDEC]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\xDE\75\120            AVX,SANDYBRIDGE
+
+[VAESDECLAST]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\xDF\75\120            AVX,SANDYBRIDGE
+
+[VAESENC]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\xDC\75\120            AVX,SANDYBRIDGE
+
+[VAESENCLAST]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\xDD\75\120            AVX,SANDYBRIDGE
+
+[VAESIMC]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\xDB\110               AVX,SANDYBRIDGE
+
+[VAESKEYGENASSIST]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\372\1\xDF\110\26            AVX,SANDYBRIDGE
+
+[VANDNPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x55\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x55\75\120        AVX,SANDYBRIDGE
+
+[VANDNPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x55\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x55\75\120            AVX,SANDYBRIDGE
+
+[VANDPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x54\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x54\75\120        AVX,SANDYBRIDGE
+
+[VANDPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x54\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x54\75\120            AVX,SANDYBRIDGE
+
+[VBLENDPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x0D\75\120\27         AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\372\1\x0D\75\120\27     AVX,SANDYBRIDGE
+
+[VBLENDPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x0C\75\120\27         AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\372\1\x0C\75\120\27     AVX,SANDYBRIDGE
+
+[VBLENDVPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,xmmreg           \361\362\372\1\x4B\75\120\367        AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,ymmreg           \361\362\364\372\1\x4B\75\120\367    AVX,SANDYBRIDGE
+
+[VBLENDVPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,xmmreg           \361\362\372\1\x4A\75\120\367        AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,ymmreg           \361\362\364\372\1\x4A\75\120\367    AVX,SANDYBRIDGE
+
+[VBROADCASTF128]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,mem128                        \361\362\364\371\1\x1A\110           AVX,SANDYBRIDGE
+
+[VBROADCASTSD]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,mem64                         \361\362\364\371\1\x19\110           AVX,SANDYBRIDGE
+
+[VBROADCASTSS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,mem32                         \361\362\364\371\1\x18\110           AVX,SANDYBRIDGE
+xmmreg,mem32                         \361\362\371\1\x18\110               AVX,SANDYBRIDGE
+
+[VCMPPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\370\1\xC2\75\120\27     AVX,SANDYBRIDGE
+
+[VCMPPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \362\370\1\xC2\75\120\27             AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \362\364\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+
+[VCMPSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64,imm8             \334\362\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg,imm8            \334\362\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+
+[VCMPSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64,imm8             \333\362\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg,imm8            \333\362\370\1\xC2\75\120\27         AVX,SANDYBRIDGE
+
+[VCOMISD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\370\1\x2F\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\370\1\x2F\110               AVX,SANDYBRIDGE
+
+[VCOMISS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \362\370\1\x2F\110                   AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \362\370\1\x2F\110                   AVX,SANDYBRIDGE
+
+[VCVTDQ2PD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \333\362\370\1\xE6\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \333\362\370\1\xE6\110               AVX,SANDYBRIDGE
+ymmreg,ymmreg                        \333\362\364\370\1\xE6\110           AVX,SANDYBRIDGE
+ymmreg,mem128                        \333\362\364\370\1\xE6\110           AVX,SANDYBRIDGE
+
+[VCVTDQ2PS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \362\370\1\x5B\110                   AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \362\364\370\1\x5B\110               AVX,SANDYBRIDGE
+
+[VCVTPD2DQ,vcvtpd2dqM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \334\362\370\1\xE6\110               AVX,SANDYBRIDGE,SI
+xmmreg,ymmrm                         \334\362\364\370\1\xE6\110           AVX,SANDYBRIDGE,SI
+
+[VCVTPD2PS,vcvtpd2psM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\x5A\110               AVX,SANDYBRIDGE,SI
+xmmreg,ymmrm                         \361\362\364\370\1\x5A\110           AVX,SANDYBRIDGE,SI
+
+[VCVTPS2DQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\x5B\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\370\1\x5B\110           AVX,SANDYBRIDGE
+
+[VCVTPS2PD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \362\370\1\x5A\110                   AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \362\370\1\x5A\110                   AVX,SANDYBRIDGE
+ymmreg,xmmrm                         \362\364\370\1\x5A\110               AVX,SANDYBRIDGE
+
+[VCVTSD2SI]
+(Ch_All, Ch_None, Ch_None)
+reg32,mem64                          \334\362\370\1\x2D\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \334\362\370\1\x2D\110               AVX,SANDYBRIDGE
+reg64,mem64                          \334\362\363\370\1\x2D\110           AVX,SANDYBRIDGE
+reg64,xmmreg                         \334\362\363\370\1\x2D\110           AVX,SANDYBRIDGE
+
+[VCVTSD2SS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x5A\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x5A\75\120            AVX,SANDYBRIDGE
+
+[VCVTSI2SD,vcvtsi2sdM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,rm32                   \334\362\370\1\x2A\75\120            AVX,SANDYBRIDGE,SD,SI
+xmmreg,xmmreg,rm64                   \334\362\363\370\1\x2A\75\120        AVX,SANDYBRIDGE,SI
+
+[VCVTSI2SS,vcvtsi2ssM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,rm32                   \333\362\370\1\x2A\75\120            AVX,SANDYBRIDGE,SD,SI
+xmmreg,xmmreg,rm64                   \333\362\363\370\1\x2A\75\120        AVX,SANDYBRIDGE,SI
+
+[VCVTSS2SD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x5A\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x5A\75\120            AVX,SANDYBRIDGE
+
+[VCVTSS2SI]
+(Ch_All, Ch_None, Ch_None)
+reg32,mem32                          \333\362\370\1\x2D\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \333\362\370\1\x2D\110               AVX,SANDYBRIDGE
+reg64,mem32                          \333\362\363\370\1\x2D\110           AVX,SANDYBRIDGE
+reg64,xmmreg                         \333\362\363\370\1\x2D\110           AVX,SANDYBRIDGE
+
+[VCVTTPD2DQ,vcvttpd2dqM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\xE6\110               AVX,SANDYBRIDGE,SI
+xmmreg,ymmrm                         \361\362\364\370\1\xE6\110           AVX,SANDYBRIDGE,SI
+
+[VCVTTPS2DQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \333\362\370\1\x5B\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \333\362\364\370\1\x5B\110           AVX,SANDYBRIDGE
+
+[VCVTTSD2SI]
+(Ch_All, Ch_None, Ch_None)
+reg32,mem64                          \334\362\370\1\x2C\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \334\362\370\1\x2C\110               AVX,SANDYBRIDGE
+reg64,mem64                          \334\362\363\370\1\x2C\110           AVX,SANDYBRIDGE
+reg64,xmmreg                         \334\362\363\370\1\x2C\110           AVX,SANDYBRIDGE
+
+[VCVTTSS2SI]
+(Ch_All, Ch_None, Ch_None)
+reg32,mem32                          \333\362\370\1\x2C\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \333\362\370\1\x2C\110               AVX,SANDYBRIDGE
+reg64,mem32                          \333\362\363\370\1\x2C\110           AVX,SANDYBRIDGE
+reg64,xmmreg                         \333\362\363\370\1\x2C\110           AVX,SANDYBRIDGE
+
+[VDIVPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x5E\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x5E\75\120        AVX,SANDYBRIDGE
+
+[VDIVPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x5E\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x5E\75\120            AVX,SANDYBRIDGE
+
+[VDIVSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x5E\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x5E\75\120            AVX,SANDYBRIDGE
+
+[VDIVSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x5E\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x5E\75\120            AVX,SANDYBRIDGE
+
+[VDPPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x41\75\120\27         AVX,SANDYBRIDGE
+
+[VDPPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x40\75\120\27         AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\372\1\x40\75\120\27     AVX,SANDYBRIDGE
+
+[VEXTRACTF128]
+(Ch_All, Ch_None, Ch_None)
+xmmrm,ymmreg,imm8                    \361\362\364\372\1\x19\101\26        AVX,SANDYBRIDGE
+
+[VEXTRACTPS]
+(Ch_All, Ch_None, Ch_None)
+rm32,xmmreg,imm8                     \361\362\372\1\x17\101\26            AVX,SANDYBRIDGE
+
+[VHADDPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x7C\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x7C\75\120        AVX,SANDYBRIDGE
+
+[VHADDPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \334\362\370\1\x7C\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \334\362\364\370\1\x7C\75\120        AVX,SANDYBRIDGE
+
+[VHSUBPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x7D\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x7D\75\120        AVX,SANDYBRIDGE
+
+[VHSUBPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \334\362\370\1\x7D\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \334\362\364\370\1\x7D\75\120        AVX,SANDYBRIDGE
+
+[VINSERTF128]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,xmmrm,imm8             \361\362\364\372\1\x18\75\120\27     AVX,SANDYBRIDGE
+
+[VINSERTPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32,imm8             \361\362\372\1\x21\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg,imm8            \361\362\372\1\x21\75\120\27         AVX,SANDYBRIDGE
+
+[VLDDQU]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem128                        \334\362\370\1\xF0\110               AVX,SANDYBRIDGE
+ymmreg,mem256                        \334\362\364\370\1\xF0\110           AVX,SANDYBRIDGE
+
+[VLDMXCSR]
+(Ch_All, Ch_None, Ch_None)
+mem32                                \362\370\1\xAE\202                   AVX,SANDYBRIDGE
+
+[VMASKMOVDQU]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg                        \361\362\370\1\xF7\110               AVX,SANDYBRIDGE
+
+[VMASKMOVPD]
+(Ch_All, Ch_None, Ch_None)
+mem256,ymmreg,ymmreg                 \361\362\364\371\1\x2F\75\102        AVX,SANDYBRIDGE
+mem128,xmmreg,xmmreg                 \361\362\371\1\x2F\75\102            AVX,SANDYBRIDGE
+ymmreg,ymmreg,mem256                 \361\362\364\371\1\x2D\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem128                 \361\362\371\1\x2D\75\120            AVX,SANDYBRIDGE
+
+[VMASKMOVPS]
+(Ch_All, Ch_None, Ch_None)
+mem256,ymmreg,ymmreg                 \361\362\364\371\1\x2E\75\102        AVX,SANDYBRIDGE
+mem128,xmmreg,xmmreg                 \361\362\371\1\x2E\75\102            AVX,SANDYBRIDGE
+ymmreg,ymmreg,mem256                 \361\362\364\371\1\x2C\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem128                 \361\362\371\1\x2C\75\120            AVX,SANDYBRIDGE
+
+[VMAXPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x5F\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x5F\75\120        AVX,SANDYBRIDGE
+
+[VMAXPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x5F\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x5F\75\120            AVX,SANDYBRIDGE
+
+[VMAXSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x5F\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x5F\75\120            AVX,SANDYBRIDGE
+
+[VMAXSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x5F\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x5F\75\120            AVX,SANDYBRIDGE
+
+[VMINPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x5D\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x5D\75\120        AVX,SANDYBRIDGE
+
+[VMINPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x5D\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x5D\75\120            AVX,SANDYBRIDGE
+
+[VMINSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x5D\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x5D\75\120            AVX,SANDYBRIDGE
+
+[VMINSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x5D\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x5D\75\120            AVX,SANDYBRIDGE
+
+[VMOVAPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\x28\110               AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \361\362\370\1\x29\101               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\370\1\x28\110           AVX,SANDYBRIDGE
+ymmrm,ymmreg                         \361\362\364\370\1\x29\101           AVX,SANDYBRIDGE
+
+[VMOVAPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \362\370\1\x28\110                   AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \362\370\1\x29\101                   AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \362\364\370\1\x28\110               AVX,SANDYBRIDGE
+ymmrm,ymmreg                         \362\364\370\1\x29\101               AVX,SANDYBRIDGE
+
+[VMOVD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,rm32                          \361\362\370\1\x6E\110               AVX,SANDYBRIDGE
+rm32,xmmreg                          \361\362\370\1\x7E\101               AVX,SANDYBRIDGE
+
+[VMOVDDUP]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm                         \334\362\364\370\1\x12\110           AVX,SANDYBRIDGE
+xmmreg,mem64                         \334\362\370\1\x12\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \334\362\370\1\x12\110               AVX,SANDYBRIDGE
+
+[VMOVDQA]
+(Ch_All, Ch_None, Ch_None)
+ymmrm,ymmreg                         \361\362\364\370\1\x7F\101           AVX,SANDYBRIDGE
+xmmreg,xmmrm                         \361\362\370\1\x6F\110               AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \361\362\370\1\x7F\101               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\370\1\x6F\110           AVX,SANDYBRIDGE
+
+[VMOVDQU]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm                         \333\362\364\370\1\x6F\110           AVX,SANDYBRIDGE
+xmmreg,xmmrm                         \333\362\370\1\x6F\110               AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \333\362\370\1\x7F\101               AVX,SANDYBRIDGE
+ymmrm,ymmreg                         \333\362\364\370\1\x7F\101           AVX,SANDYBRIDGE
+
+[VMOVHLPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmreg                 \362\370\1\x12\75\120                AVX,SANDYBRIDGE
+
+[VMOVHPD]
+(Ch_All, Ch_None, Ch_None)
+mem64,xmmreg                         \361\362\370\1\x17\101               AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem64                  \361\362\370\1\x16\75\120            AVX,SANDYBRIDGE
+
+[VMOVHPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \362\370\1\x16\75\120                AVX,SANDYBRIDGE
+mem64,xmmreg                         \362\370\1\x17\101                   AVX,SANDYBRIDGE
+
+[VMOVLHPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmreg                 \362\370\1\x16\75\120                AVX,SANDYBRIDGE
+
+[VMOVLPD]
+(Ch_All, Ch_None, Ch_None)
+mem64,xmmreg                         \361\362\370\1\x13\101               AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem64                  \361\362\370\1\x12\75\120            AVX,SANDYBRIDGE
+
+[VMOVLPS]
+(Ch_All, Ch_None, Ch_None)
+mem64,xmmreg                         \362\370\1\x13\101                   AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem64                  \362\370\1\x12\75\120                AVX,SANDYBRIDGE
+
+[VMOVMSKPD]
+(Ch_All, Ch_None, Ch_None)
+reg32,ymmreg                         \361\362\364\370\1\x50\110           AVX,SANDYBRIDGE
+reg64,xmmreg                         \361\362\370\1\x50\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \361\362\370\1\x50\110               AVX,SANDYBRIDGE
+reg64,ymmreg                         \361\362\364\370\1\x50\110           AVX,SANDYBRIDGE
+
+[VMOVMSKPS]
+(Ch_All, Ch_None, Ch_None)
+reg32,ymmreg                         \362\364\370\1\x50\110               AVX,SANDYBRIDGE
+reg64,xmmreg                         \362\370\1\x50\110                   AVX,SANDYBRIDGE
+reg32,xmmreg                         \362\370\1\x50\110                   AVX,SANDYBRIDGE
+reg64,ymmreg                         \362\364\370\1\x50\110               AVX,SANDYBRIDGE
+
+[VMOVNTDQ]
+(Ch_All, Ch_None, Ch_None)
+mem128,xmmreg                        \361\362\370\1\xE7\101               AVX,SANDYBRIDGE
+mem256,ymmreg                        \361\362\364\370\1\xE7\101           AVX,SANDYBRIDGE
+
+[VMOVNTDQA]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem128                        \361\362\371\1\x2A\110               AVX,SANDYBRIDGE
+
+[VMOVNTPD]
+(Ch_All, Ch_None, Ch_None)
+mem256,ymmreg                        \361\362\364\370\1\x2B\101           AVX,SANDYBRIDGE
+mem128,xmmreg                        \361\362\370\1\x2B\101               AVX,SANDYBRIDGE
+
+[VMOVNTPS]
+(Ch_All, Ch_None, Ch_None)
+mem128,ymmreg                        \362\364\370\1\x2B\101               AVX,SANDYBRIDGE
+mem128,xmmreg                        \362\370\1\x2B\101                   AVX,SANDYBRIDGE
+
+[VMOVQ]
+(Ch_All, Ch_None, Ch_None)
+rm64,xmmreg                          \361\362\363\370\1\x7E\101           AVX,SANDYBRIDGE
+xmmreg,rm64                          \361\362\363\370\1\x6E\110           AVX,SANDYBRIDGE
+
+[VMOVSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x10\75\120            AVX,SANDYBRIDGE
+xmmreg,mem64                         \334\362\370\1\x10\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x11\75\102            AVX,SANDYBRIDGE
+mem64,xmmreg                         \334\362\370\1\x11\101               AVX,SANDYBRIDGE
+
+[VMOVSHDUP]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \333\362\370\1\x16\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \333\362\364\370\1\x16\110           AVX,SANDYBRIDGE
+
+[VMOVSLDUP]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \333\362\370\1\x12\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \333\362\364\370\1\x12\110           AVX,SANDYBRIDGE
+
+[VMOVSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x10\75\120            AVX,SANDYBRIDGE
+xmmreg,mem64                         \333\362\370\1\x10\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x11\75\102            AVX,SANDYBRIDGE
+mem64,xmmreg                         \333\362\370\1\x11\101               AVX,SANDYBRIDGE
+
+[VMOVUPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\x10\110               AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \361\362\370\1\x11\101               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\370\1\x10\110           AVX,SANDYBRIDGE
+ymmrm,ymmreg                         \361\362\364\370\1\x11\101           AVX,SANDYBRIDGE
+
+[VMOVUPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \362\370\1\x10\110                   AVX,SANDYBRIDGE
+xmmrm,xmmreg                         \362\370\1\x11\101                   AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \362\364\370\1\x10\110               AVX,SANDYBRIDGE
+ymmrm,ymmreg                         \362\364\370\1\x11\101               AVX,SANDYBRIDGE
+
+[VMPSADBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x42\75\120\27         AVX,SANDYBRIDGE
+
+[VMULPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x59\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x59\75\120        AVX,SANDYBRIDGE
+
+[VMULPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x59\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x59\75\120            AVX,SANDYBRIDGE
+
+[VMULSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x59\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x59\75\120            AVX,SANDYBRIDGE
+
+[VMULSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x59\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x59\75\120            AVX,SANDYBRIDGE
+
+[VORPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x56\75\120            AVX,SANDYBRIDGE
+
+[VORPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x56\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x56\75\120            AVX,SANDYBRIDGE
+
+[VPABSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\x1C\110               AVX,SANDYBRIDGE
+
+[VPABSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\x1E\110               AVX,SANDYBRIDGE
+
+[VPABSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\x1D\110               AVX,SANDYBRIDGE
+
+[VPACKSSDW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x6B\75\120            AVX,SANDYBRIDGE
+
+[VPACKSSWB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x63\75\120            AVX,SANDYBRIDGE
+
+[VPACKUSDW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x2B\75\120            AVX,SANDYBRIDGE
+
+[VPACKUSWB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x67\75\120            AVX,SANDYBRIDGE
+
+[VPADDB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xFC\75\120            AVX,SANDYBRIDGE
+
+[VPADDD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xFE\75\120            AVX,SANDYBRIDGE
+
+[VPADDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD4\75\120            AVX,SANDYBRIDGE
+
+[VPADDSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xEC\75\120            AVX,SANDYBRIDGE
+
+[VPADDSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xED\75\120            AVX,SANDYBRIDGE
+
+[VPADDUSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDC\75\120            AVX,SANDYBRIDGE
+
+[VPADDUSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDD\75\120            AVX,SANDYBRIDGE
+
+[VPADDW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xFD\75\120            AVX,SANDYBRIDGE
+
+[VPALIGNR]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x0F\75\120\27         AVX,SANDYBRIDGE
+
+[VPAND]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDB\75\120            AVX,SANDYBRIDGE
+
+[VPANDN]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDF\75\120            AVX,SANDYBRIDGE
+
+[VPAVGB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE0\75\120            AVX,SANDYBRIDGE
+
+[VPAVGW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE3\75\120            AVX,SANDYBRIDGE
+
+[VPBLENDVB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,xmmreg           \361\362\372\1\x4C\75\120\367        AVX,SANDYBRIDGE
+
+[VPBLENDW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x0E\75\120\27         AVX,SANDYBRIDGE
+
+[VPCLMULQDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\372\1\x44\75\120\27         AVX,SANDYBRIDGE
+
+[VPCMPEQB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x74\75\120            AVX,SANDYBRIDGE
+
+[VPCMPEQD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x76\75\120            AVX,SANDYBRIDGE
+
+[VPCMPEQQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x29\75\120            AVX,SANDYBRIDGE
+
+[VPCMPEQW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x75\75\120            AVX,SANDYBRIDGE
+
+[VPCMPESTRI]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\372\1\x61\110\26            AVX,SANDYBRIDGE
+
+[VPCMPESTRM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\372\1\x60\110\26            AVX,SANDYBRIDGE
+
+[VPCMPGTB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x64\75\120            AVX,SANDYBRIDGE
+
+[VPCMPGTD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x66\75\120            AVX,SANDYBRIDGE
+
+[VPCMPGTQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x37\75\120            AVX,SANDYBRIDGE
+
+[VPCMPGTW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x65\75\120            AVX,SANDYBRIDGE
+
+[VPCMPISTRI]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\372\1\x63\110\26            AVX,SANDYBRIDGE
+
+[VPCMPISTRM]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\372\1\x62\110\26            AVX,SANDYBRIDGE
+
+[VPERM2F128]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\372\1\x06\75\120\27     AVX,SANDYBRIDGE
+
+[VPERMILPD]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,ymmrm                  \361\362\364\371\1\x0D\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmrm,imm8                    \361\362\372\1\x05\110\26            AVX,SANDYBRIDGE
+ymmreg,ymmrm,imm8                    \361\362\364\372\1\x05\110\26        AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x0D\75\120            AVX,SANDYBRIDGE
+
+[VPERMILPS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmreg,ymmrm                  \361\362\364\371\1\x0C\75\120        AVX,SANDYBRIDGE
+xmmreg,xmmrm,imm8                    \361\362\372\1\x04\110\26            AVX,SANDYBRIDGE
+ymmreg,ymmrm,imm8                    \361\362\364\372\1\x04\110\26        AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x0C\75\120            AVX,SANDYBRIDGE
+
+[VPEXTRB]
+(Ch_All, Ch_None, Ch_None)
+reg32,xmmreg,imm8                    \361\362\372\1\x14\101\26            AVX,SANDYBRIDGE
+reg64,xmmreg,imm8                    \361\362\372\1\x14\101\26            AVX,SANDYBRIDGE
+mem8,xmmreg,imm8                     \361\362\372\1\x14\101\26            AVX,SANDYBRIDGE
+
+[VPEXTRD]
+(Ch_All, Ch_None, Ch_None)
+rm32,xmmreg,imm8                     \361\362\372\1\x16\101\26            AVX,SANDYBRIDGE
+
+[VPEXTRQ]
+(Ch_All, Ch_None, Ch_None)
+rm64,xmmreg,imm8                     \361\362\363\372\1\x16\101\26        AVX,SANDYBRIDGE
+
+[VPEXTRW]
+(Ch_All, Ch_None, Ch_None)
+reg32,xmmreg,imm8                    \361\362\370\1\xC5\110\26            AVX,SANDYBRIDGE
+reg64,xmmreg,imm8                    \361\362\370\1\xC5\110\26            AVX,SANDYBRIDGE
+reg32,xmmreg,imm8                    \361\362\372\1\x15\101\26            AVX,SANDYBRIDGE
+reg64,xmmreg,imm8                    \361\362\372\1\x15\101\26            AVX,SANDYBRIDGE
+mem16,xmmreg,imm8                    \361\362\372\1\x15\101\26            AVX,SANDYBRIDGE
+
+
+[VPHADDD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x02\75\120            AVX,SANDYBRIDGE
+
+[VPHADDSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x03\75\120            AVX,SANDYBRIDGE
+
+[VPHADDW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x01\75\120            AVX,SANDYBRIDGE
+
+[VPHMINPOSUW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\x41\110               AVX,SANDYBRIDGE
+
+[VPHSUBD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x06\75\120            AVX,SANDYBRIDGE
+
+[VPHSUBSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x07\75\120            AVX,SANDYBRIDGE
+
+[VPHSUBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x05\75\120            AVX,SANDYBRIDGE
+
+[VPINSRB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,reg32,imm8             \361\362\372\1\x20\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem8,imm8              \361\362\372\1\x20\75\120\27         AVX,SANDYBRIDGE
+
+[VPINSRD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,rm32,imm8              \361\362\372\1\x22\75\120\27         AVX,SANDYBRIDGE
+
+[VPINSRQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,rm64,imm8              \361\362\363\372\1\x22\75\120\27     AVX,SANDYBRIDGE
+
+[VPINSRW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,reg32,imm8             \361\362\370\1\xC4\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,mem16,imm8             \361\362\370\1\xC4\75\120\27         AVX,SANDYBRIDGE
+
+[VPMADDUBSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x04\75\120            AVX,SANDYBRIDGE
+
+[VPMADDWD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF5\75\120            AVX,SANDYBRIDGE
+
+[VPMAXSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3C\75\120            AVX,SANDYBRIDGE
+
+[VPMAXSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3D\75\120            AVX,SANDYBRIDGE
+
+[VPMAXSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xEE\75\120            AVX,SANDYBRIDGE
+
+[VPMAXUB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDE\75\120            AVX,SANDYBRIDGE
+
+[VPMAXUD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3F\75\120            AVX,SANDYBRIDGE
+
+[VPMAXUW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3E\75\120            AVX,SANDYBRIDGE
+
+[VPMINSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x38\75\120            AVX,SANDYBRIDGE
+
+[VPMINSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x39\75\120            AVX,SANDYBRIDGE
+
+[VPMINSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xEA\75\120            AVX,SANDYBRIDGE
+
+[VPMINUB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xDA\75\120            AVX,SANDYBRIDGE
+
+[VPMINUD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3B\75\120            AVX,SANDYBRIDGE
+
+[VPMINUW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x3A\75\120            AVX,SANDYBRIDGE
+
+[VPMOVMSKB]
+(Ch_All, Ch_None, Ch_None)
+reg64,xmmreg                         \361\362\370\1\xD7\110               AVX,SANDYBRIDGE
+reg32,xmmreg                         \361\362\370\1\xD7\110               AVX,SANDYBRIDGE
+
+[VPMOVSXBD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \361\362\371\1\x21\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x21\110               AVX,SANDYBRIDGE
+
+[VPMOVSXBQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem16                         \361\362\371\1\x22\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x22\110               AVX,SANDYBRIDGE
+
+[VPMOVSXBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x20\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x20\110               AVX,SANDYBRIDGE
+
+[VPMOVSXDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x25\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x25\110               AVX,SANDYBRIDGE
+
+[VPMOVSXWD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x23\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x23\110               AVX,SANDYBRIDGE
+
+[VPMOVSXWQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \361\362\371\1\x24\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x24\110               AVX,SANDYBRIDGE
+
+[VPMOVZXBD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \361\362\371\1\x31\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x31\110               AVX,SANDYBRIDGE
+
+[VPMOVZXBQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem16                         \361\362\371\1\x32\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x32\110               AVX,SANDYBRIDGE
+
+[VPMOVZXBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x30\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x30\110               AVX,SANDYBRIDGE
+
+[VPMOVZXDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x35\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x35\110               AVX,SANDYBRIDGE
+
+[VPMOVZXWD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\371\1\x33\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x33\110               AVX,SANDYBRIDGE
+
+[VPMOVZXWQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \361\362\371\1\x34\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\371\1\x34\110               AVX,SANDYBRIDGE
+
+[VPMULDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x28\75\120            AVX,SANDYBRIDGE
+
+[VPMULHRSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x0B\75\120            AVX,SANDYBRIDGE
+
+[VPMULHUW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE4\75\120            AVX,SANDYBRIDGE
+
+[VPMULHW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE5\75\120            AVX,SANDYBRIDGE
+
+[VPMULLD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x40\75\120            AVX,SANDYBRIDGE
+
+[VPMULLW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD5\75\120            AVX,SANDYBRIDGE
+
+[VPMULUDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF4\75\120            AVX,SANDYBRIDGE
+
+[VPOR]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xEB\75\120            AVX,SANDYBRIDGE
+
+[VPSADBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF6\75\120            AVX,SANDYBRIDGE
+
+[VPSHUFB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x00\75\120            AVX,SANDYBRIDGE
+
+[VPSHUFD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \361\362\370\1\x70\110\26            AVX,SANDYBRIDGE
+
+[VPSHUFHW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \333\362\370\1\x70\110\26            AVX,SANDYBRIDGE
+
+[VPSHUFLW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm,imm8                    \334\362\370\1\x70\110\26            AVX,SANDYBRIDGE
+
+[VPSIGNB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x08\75\120            AVX,SANDYBRIDGE
+
+[VPSIGND]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x0A\75\120            AVX,SANDYBRIDGE
+
+[VPSIGNW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\371\1\x09\75\120            AVX,SANDYBRIDGE
+
+[VPSLLD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x72\74\216\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF2\75\120            AVX,SANDYBRIDGE
+
+[VPSLLDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x73\74\217\26         AVX,SANDYBRIDGE
+
+[VPSLLQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF3\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,imm8                   \361\362\370\1\x73\74\216\26         AVX,SANDYBRIDGE
+
+[VPSLLW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x71\74\216\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF1\75\120            AVX,SANDYBRIDGE
+
+[VPSRAD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x72\74\214\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE2\75\120            AVX,SANDYBRIDGE
+
+[VPSRAW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x71\74\214\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE1\75\120            AVX,SANDYBRIDGE
+
+[VPSRLD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x72\74\212\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD2\75\120            AVX,SANDYBRIDGE
+
+[VPSRLDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x73\74\213\26         AVX,SANDYBRIDGE
+
+[VPSRLQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x73\74\212\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD3\75\120            AVX,SANDYBRIDGE
+
+[VPSRLW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,imm8                   \361\362\370\1\x71\74\212\26         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD1\75\120            AVX,SANDYBRIDGE
+
+[VPSUBB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF8\75\120            AVX,SANDYBRIDGE
+
+[VPSUBD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xFA\75\120            AVX,SANDYBRIDGE
+
+[VPSUBQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xFB\75\120            AVX,SANDYBRIDGE
+
+[VPSUBSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE8\75\120            AVX,SANDYBRIDGE
+
+[VPSUBSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xE9\75\120            AVX,SANDYBRIDGE
+
+[VPSUBUSB]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD8\75\120            AVX,SANDYBRIDGE
+
+[VPSUBUSW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xD9\75\120            AVX,SANDYBRIDGE
+
+[VPSUBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xF9\75\120            AVX,SANDYBRIDGE
+
+[VPTEST]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm                         \361\362\364\371\1\x17\110           AVX,SANDYBRIDGE
+xmmreg,xmmrm                         \361\362\371\1\x17\110               AVX,SANDYBRIDGE
+
+[VPUNPCKHBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x68\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKHDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x6A\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKHQDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x6D\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKHWD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x69\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKLBW]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x60\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKLDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x62\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKLQDQ]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x6C\75\120            AVX,SANDYBRIDGE
+
+[VPUNPCKLWD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x61\75\120            AVX,SANDYBRIDGE
+
+[VPXOR]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\xEF\75\120            AVX,SANDYBRIDGE
+
+[VRCPPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \362\370\1\x53\110                   AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \362\364\370\1\x53\110               AVX,SANDYBRIDGE
+
+[VRCPSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x53\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x53\75\120            AVX,SANDYBRIDGE
+
+[VROUNDPD]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm,imm8                    \361\362\364\372\1\x09\110\26        AVX,SANDYBRIDGE
+xmmreg,xmmrm,imm8                    \361\362\372\1\x09\110\26            AVX,SANDYBRIDGE
+
+[VROUNDPS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm,imm8                    \361\362\364\372\1\x08\110\26        AVX,SANDYBRIDGE
+xmmreg,xmmrm,imm8                    \361\362\372\1\x08\110\26            AVX,SANDYBRIDGE
+
+[VROUNDSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64,imm8             \361\362\372\1\x0B\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg,imm8            \361\362\372\1\x0B\75\120\27         AVX,SANDYBRIDGE
+
+[VROUNDSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32,imm8             \361\362\372\1\x0A\75\120\27         AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg,imm8            \361\362\372\1\x0A\75\120\27         AVX,SANDYBRIDGE
+
+[VRSQRTPS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm                         \362\364\370\1\x52\110               AVX,SANDYBRIDGE
+xmmreg,xmmrm                         \362\370\1\x52\110                   AVX,SANDYBRIDGE
+
+[VRSQRTSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x52\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x52\75\120            AVX,SANDYBRIDGE
+
+[VSHUFPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \361\362\370\1\xC6\75\120\27         AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \361\362\364\370\1\xC6\75\120\27     AVX,SANDYBRIDGE
+
+[VSHUFPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm,imm8             \362\370\1\xC6\75\120\27             AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm,imm8             \362\364\370\1\xC6\75\120\27         AVX,SANDYBRIDGE
+
+[VSQRTPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\370\1\x51\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\370\1\x51\110           AVX,SANDYBRIDGE
+
+[VSQRTPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \362\370\1\x51\110                   AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \362\364\370\1\x51\110               AVX,SANDYBRIDGE
+
+[VSQRTSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x51\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x51\75\120            AVX,SANDYBRIDGE
+
+[VSQRTSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x51\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x51\75\120            AVX,SANDYBRIDGE
+
+[VSTMXCSR]
+(Ch_All, Ch_None, Ch_None)
+mem32                                \362\370\1\xAE\203                   AVX,SANDYBRIDGE
+
+[VSUBPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x5C\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x5C\75\120        AVX,SANDYBRIDGE
+
+[VSUBPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x5C\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x5C\75\120            AVX,SANDYBRIDGE
+
+[VSUBSD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem64                  \334\362\370\1\x5C\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \334\362\370\1\x5C\75\120            AVX,SANDYBRIDGE
+
+[VSUBSS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,mem32                  \333\362\370\1\x5C\75\120            AVX,SANDYBRIDGE
+xmmreg,xmmreg,xmmreg                 \333\362\370\1\x5C\75\120            AVX,SANDYBRIDGE
+
+[VTESTPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmrm                         \361\362\371\1\x0F\110               AVX,SANDYBRIDGE
+ymmreg,ymmrm                         \361\362\364\371\1\x0F\110           AVX,SANDYBRIDGE
+
+[VTESTPS]
+(Ch_All, Ch_None, Ch_None)
+ymmreg,ymmrm                         \361\362\364\371\1\x0E\110           AVX,SANDYBRIDGE
+xmmreg,xmmrm                         \361\362\371\1\x0E\110               AVX,SANDYBRIDGE
+
+[VUCOMISD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem64                         \361\362\370\1\x2E\110               AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \361\362\370\1\x2E\110               AVX,SANDYBRIDGE
+
+[VUCOMISS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,mem32                         \362\370\1\x2E\110                   AVX,SANDYBRIDGE
+xmmreg,xmmreg                        \362\370\1\x2E\110                   AVX,SANDYBRIDGE
+
+[VUNPCKHPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x15\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x15\75\120        AVX,SANDYBRIDGE
+
+[VUNPCKHPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x15\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x15\75\120            AVX,SANDYBRIDGE
+
+[VUNPCKLPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x14\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x14\75\120        AVX,SANDYBRIDGE
+
+[VUNPCKLPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x14\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x14\75\120            AVX,SANDYBRIDGE
+
+[VXORPD]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \361\362\370\1\x57\75\120            AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \361\362\364\370\1\x57\75\120        AVX,SANDYBRIDGE
+
+[VXORPS]
+(Ch_All, Ch_None, Ch_None)
+xmmreg,xmmreg,xmmrm                  \362\370\1\x57\75\120                AVX,SANDYBRIDGE
+ymmreg,ymmreg,ymmrm                  \362\364\370\1\x57\75\120            AVX,SANDYBRIDGE
+
+[VZEROALL]
+(Ch_All, Ch_None, Ch_None)
+void                                 \362\364\370\1\x77                   AVX,SANDYBRIDGE
+
+[VZEROUPPER]
+(Ch_All, Ch_None, Ch_None)
+void                                 \362\370\1\x77                       AVX,SANDYBRIDGE
diff --git a/compiler/x86/x86reg.dat b/compiler/x86/x86reg.dat
index 1ebea360b3..d448e5b0c9 100644
--- a/compiler/x86/x86reg.dat
+++ b/compiler/x86/x86reg.dat
@@ -122,19 +122,36 @@ NR_MM5,$03000005,mm5,%mm5,mm5,mm5,34,34,46,OT_MMXREG,5
 NR_MM6,$03000006,mm6,%mm6,mm6,mm6,35,35,47,OT_MMXREG,6
 NR_MM7,$03000007,mm7,%mm7,mm7,mm7,36,36,48,OT_MMXREG,7
 
-NR_XMM0,$04000000,xmm0,%xmm0,xmm0,xmm0,21,21,17,OT_XMMREG,0
-NR_XMM1,$04000001,xmm1,%xmm1,xmm1,xmm1,22,22,18,OT_XMMREG,1
-NR_XMM2,$04000002,xmm2,%xmm2,xmm2,xmm2,23,23,19,OT_XMMREG,2
-NR_XMM3,$04000003,xmm3,%xmm3,xmm3,xmm3,24,24,20,OT_XMMREG,3
-NR_XMM4,$04000004,xmm4,%xmm4,xmm4,xmm4,25,25,21,OT_XMMREG,4
-NR_XMM5,$04000005,xmm5,%xmm5,xmm5,xmm5,26,26,22,OT_XMMREG,5
-NR_XMM6,$04000006,xmm6,%xmm6,xmm6,xmm6,27,27,23,OT_XMMREG,6
-NR_XMM7,$04000007,xmm7,%xmm7,xmm7,xmm7,28,28,24,OT_XMMREG,7
-NR_XMM8,$04000008,xmm8,%xmm8,xmm8,xmm8,-1,-1,25,OT_XMMREG,0,64
-NR_XMM9,$04000009,xmm9,%xmm9,xmm9,xmm9,-1,-1,26,OT_XMMREG,1,64
-NR_XMM10,$0400000a,xmm10,%xmm10,xmm10,xmm10,-1,-1,27,OT_XMMREG,2,64
-NR_XMM11,$0400000b,xmm11,%xmm11,xmm11,xmm11,-1,-1,28,OT_XMMREG,3,64
-NR_XMM12,$0400000c,xmm12,%xmm12,xmm12,xmm12,-1,-1,29,OT_XMMREG,4,64
-NR_XMM13,$0400000d,xmm13,%xmm13,xmm13,xmm13,-1,-1,30,OT_XMMREG,5,64
-NR_XMM14,$0400000e,xmm14,%xmm14,xmm14,xmm14,-1,-1,31,OT_XMMREG,6,64
-NR_XMM15,$0400000f,xmm15,%xmm15,xmm15,xmm15,-1,-1,32,OT_XMMREG,7,64
+NR_XMM0,$040C0000,xmm0,%xmm0,xmm0,xmm0,21,21,17,OT_XMMREG,0
+NR_XMM1,$040C0001,xmm1,%xmm1,xmm1,xmm1,22,22,18,OT_XMMREG,1
+NR_XMM2,$040C0002,xmm2,%xmm2,xmm2,xmm2,23,23,19,OT_XMMREG,2
+NR_XMM3,$040C0003,xmm3,%xmm3,xmm3,xmm3,24,24,20,OT_XMMREG,3
+NR_XMM4,$040C0004,xmm4,%xmm4,xmm4,xmm4,25,25,21,OT_XMMREG,4
+NR_XMM5,$040C0005,xmm5,%xmm5,xmm5,xmm5,26,26,22,OT_XMMREG,5
+NR_XMM6,$040C0006,xmm6,%xmm6,xmm6,xmm6,27,27,23,OT_XMMREG,6
+NR_XMM7,$040C0007,xmm7,%xmm7,xmm7,xmm7,28,28,24,OT_XMMREG,7
+NR_XMM8,$040C0008,xmm8,%xmm8,xmm8,xmm8,-1,-1,25,OT_XMMREG,0,64
+NR_XMM9,$040C0009,xmm9,%xmm9,xmm9,xmm9,-1,-1,26,OT_XMMREG,1,64
+NR_XMM10,$040C000a,xmm10,%xmm10,xmm10,xmm10,-1,-1,27,OT_XMMREG,2,64
+NR_XMM11,$040C000b,xmm11,%xmm11,xmm11,xmm11,-1,-1,28,OT_XMMREG,3,64
+NR_XMM12,$040C000c,xmm12,%xmm12,xmm12,xmm12,-1,-1,29,OT_XMMREG,4,64
+NR_XMM13,$040C000d,xmm13,%xmm13,xmm13,xmm13,-1,-1,30,OT_XMMREG,5,64
+NR_XMM14,$040C000e,xmm14,%xmm14,xmm14,xmm14,-1,-1,31,OT_XMMREG,6,64
+NR_XMM15,$040C000f,xmm15,%xmm15,xmm15,xmm15,-1,-1,32,OT_XMMREG,7,64
+
+NR_YMM0,$040D0000,ymm0,%ymm0,ymm0,ymm0,21,21,17,OT_YMMREG,0
+NR_YMM1,$040D0001,ymm1,%ymm1,ymm1,ymm1,22,22,18,OT_YMMREG,1
+NR_YMM2,$040D0002,ymm2,%ymm2,ymm2,ymm2,23,23,19,OT_YMMREG,2
+NR_YMM3,$040D0003,ymm3,%ymm3,ymm3,ymm3,24,24,20,OT_YMMREG,3
+NR_YMM4,$040D0004,ymm4,%ymm4,ymm4,ymm4,25,25,21,OT_YMMREG,4
+NR_YMM5,$040D0005,ymm5,%ymm5,ymm5,ymm5,26,26,22,OT_YMMREG,5
+NR_YMM6,$040D0006,ymm6,%ymm6,ymm6,ymm6,27,27,23,OT_YMMREG,6
+NR_YMM7,$040D0007,ymm7,%ymm7,ymm7,ymm7,28,28,24,OT_YMMREG,7
+NR_YMM8,$040D0008,ymm8,%ymm8,ymm8,ymm8,-1,-1,25,OT_YMMREG,0,64
+NR_YMM9,$040D0009,ymm9,%ymm9,ymm9,ymm9,-1,-1,26,OT_YMMREG,1,64
+NR_YMM10,$040D000a,ymm10,%ymm10,ymm10,ymm10,-1,-1,27,OT_YMMREG,2,64
+NR_YMM11,$040D000b,ymm11,%ymm11,ymm11,ymm11,-1,-1,28,OT_YMMREG,3,64
+NR_YMM12,$040D000c,ymm12,%ymm12,ymm12,ymm12,-1,-1,29,OT_YMMREG,4,64
+NR_YMM13,$040D000d,ymm13,%ymm13,ymm13,ymm13,-1,-1,30,OT_YMMREG,5,64
+NR_YMM14,$040D000e,ymm14,%ymm14,ymm14,ymm14,-1,-1,31,OT_YMMREG,6,64
+NR_YMM15,$040D000f,ymm15,%ymm15,ymm15,ymm15,-1,-1,32,OT_YMMREG,7,64
diff --git a/compiler/x86_64/cpubase.inc b/compiler/x86_64/cpubase.inc
index 5ad43262b3..68e0763597 100644
--- a/compiler/x86_64/cpubase.inc
+++ b/compiler/x86_64/cpubase.inc
@@ -34,7 +34,8 @@ type
     S_MD,
     S_NEAR,S_FAR,S_SHORT,
     S_T,
-    S_XMM
+    S_XMM,
+    S_YMM
   );
 
 {*****************************************************************************
diff --git a/compiler/x86_64/r8664ari.inc b/compiler/x86_64/r8664ari.inc
index bdce69ce50..54988eb9e6 100644
--- a/compiler/x86_64/r8664ari.inc
+++ b/compiler/x86_64/r8664ari.inc
@@ -123,4 +123,20 @@
 116,
 117,
 118,
+125,
+126,
+135,
+136,
+137,
+138,
+139,
+140,
+127,
+128,
+129,
+130,
+131,
+132,
+133,
+134,
 0
diff --git a/compiler/x86_64/r8664att.inc b/compiler/x86_64/r8664att.inc
index f9539b56f8..b82057950f 100644
--- a/compiler/x86_64/r8664att.inc
+++ b/compiler/x86_64/r8664att.inc
@@ -123,4 +123,20 @@
 '%xmm12',
 '%xmm13',
 '%xmm14',
-'%xmm15'
+'%xmm15',
+'%ymm0',
+'%ymm1',
+'%ymm2',
+'%ymm3',
+'%ymm4',
+'%ymm5',
+'%ymm6',
+'%ymm7',
+'%ymm8',
+'%ymm9',
+'%ymm10',
+'%ymm11',
+'%ymm12',
+'%ymm13',
+'%ymm14',
+'%ymm15'
diff --git a/compiler/x86_64/r8664con.inc b/compiler/x86_64/r8664con.inc
index ae6a0d28e3..d202693242 100644
--- a/compiler/x86_64/r8664con.inc
+++ b/compiler/x86_64/r8664con.inc
@@ -108,19 +108,35 @@ NR_MM4 = tregister($03000004);
 NR_MM5 = tregister($03000005);
 NR_MM6 = tregister($03000006);
 NR_MM7 = tregister($03000007);
-NR_XMM0 = tregister($04000000);
-NR_XMM1 = tregister($04000001);
-NR_XMM2 = tregister($04000002);
-NR_XMM3 = tregister($04000003);
-NR_XMM4 = tregister($04000004);
-NR_XMM5 = tregister($04000005);
-NR_XMM6 = tregister($04000006);
-NR_XMM7 = tregister($04000007);
-NR_XMM8 = tregister($04000008);
-NR_XMM9 = tregister($04000009);
-NR_XMM10 = tregister($0400000a);
-NR_XMM11 = tregister($0400000b);
-NR_XMM12 = tregister($0400000c);
-NR_XMM13 = tregister($0400000d);
-NR_XMM14 = tregister($0400000e);
-NR_XMM15 = tregister($0400000f);
+NR_XMM0 = tregister($040C0000);
+NR_XMM1 = tregister($040C0001);
+NR_XMM2 = tregister($040C0002);
+NR_XMM3 = tregister($040C0003);
+NR_XMM4 = tregister($040C0004);
+NR_XMM5 = tregister($040C0005);
+NR_XMM6 = tregister($040C0006);
+NR_XMM7 = tregister($040C0007);
+NR_XMM8 = tregister($040C0008);
+NR_XMM9 = tregister($040C0009);
+NR_XMM10 = tregister($040C000a);
+NR_XMM11 = tregister($040C000b);
+NR_XMM12 = tregister($040C000c);
+NR_XMM13 = tregister($040C000d);
+NR_XMM14 = tregister($040C000e);
+NR_XMM15 = tregister($040C000f);
+NR_YMM0 = tregister($040D0000);
+NR_YMM1 = tregister($040D0001);
+NR_YMM2 = tregister($040D0002);
+NR_YMM3 = tregister($040D0003);
+NR_YMM4 = tregister($040D0004);
+NR_YMM5 = tregister($040D0005);
+NR_YMM6 = tregister($040D0006);
+NR_YMM7 = tregister($040D0007);
+NR_YMM8 = tregister($040D0008);
+NR_YMM9 = tregister($040D0009);
+NR_YMM10 = tregister($040D000a);
+NR_YMM11 = tregister($040D000b);
+NR_YMM12 = tregister($040D000c);
+NR_YMM13 = tregister($040D000d);
+NR_YMM14 = tregister($040D000e);
+NR_YMM15 = tregister($040D000f);
diff --git a/compiler/x86_64/r8664dwrf.inc b/compiler/x86_64/r8664dwrf.inc
index 27f736cb5c..0f2b2ffe33 100644
--- a/compiler/x86_64/r8664dwrf.inc
+++ b/compiler/x86_64/r8664dwrf.inc
@@ -123,4 +123,20 @@
 29,
 30,
 31,
+32,
+17,
+18,
+19,
+20,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
+28,
+29,
+30,
+31,
 32
diff --git a/compiler/x86_64/r8664int.inc b/compiler/x86_64/r8664int.inc
index 55ea578074..25ecb9c5b1 100644
--- a/compiler/x86_64/r8664int.inc
+++ b/compiler/x86_64/r8664int.inc
@@ -123,4 +123,20 @@
 'xmm12',
 'xmm13',
 'xmm14',
-'xmm15'
+'xmm15',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7',
+'ymm8',
+'ymm9',
+'ymm10',
+'ymm11',
+'ymm12',
+'ymm13',
+'ymm14',
+'ymm15'
diff --git a/compiler/x86_64/r8664iri.inc b/compiler/x86_64/r8664iri.inc
index 67d9df19f9..e138ae7bc3 100644
--- a/compiler/x86_64/r8664iri.inc
+++ b/compiler/x86_64/r8664iri.inc
@@ -123,4 +123,20 @@
 115,
 116,
 117,
-118
+118,
+125,
+126,
+135,
+136,
+137,
+138,
+139,
+140,
+127,
+128,
+129,
+130,
+131,
+132,
+133,
+134
diff --git a/compiler/x86_64/r8664nor.inc b/compiler/x86_64/r8664nor.inc
index 7b3502fb2e..fc3c83871f 100644
--- a/compiler/x86_64/r8664nor.inc
+++ b/compiler/x86_64/r8664nor.inc
@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86reg.dat }
-125
+141
diff --git a/compiler/x86_64/r8664num.inc b/compiler/x86_64/r8664num.inc
index 01e0b0dfa7..96b7d6ef53 100644
--- a/compiler/x86_64/r8664num.inc
+++ b/compiler/x86_64/r8664num.inc
@@ -108,19 +108,35 @@ tregister($03000004),
 tregister($03000005),
 tregister($03000006),
 tregister($03000007),
-tregister($04000000),
-tregister($04000001),
-tregister($04000002),
-tregister($04000003),
-tregister($04000004),
-tregister($04000005),
-tregister($04000006),
-tregister($04000007),
-tregister($04000008),
-tregister($04000009),
-tregister($0400000a),
-tregister($0400000b),
-tregister($0400000c),
-tregister($0400000d),
-tregister($0400000e),
-tregister($0400000f)
+tregister($040C0000),
+tregister($040C0001),
+tregister($040C0002),
+tregister($040C0003),
+tregister($040C0004),
+tregister($040C0005),
+tregister($040C0006),
+tregister($040C0007),
+tregister($040C0008),
+tregister($040C0009),
+tregister($040C000a),
+tregister($040C000b),
+tregister($040C000c),
+tregister($040C000d),
+tregister($040C000e),
+tregister($040C000f),
+tregister($040D0000),
+tregister($040D0001),
+tregister($040D0002),
+tregister($040D0003),
+tregister($040D0004),
+tregister($040D0005),
+tregister($040D0006),
+tregister($040D0007),
+tregister($040D0008),
+tregister($040D0009),
+tregister($040D000a),
+tregister($040D000b),
+tregister($040D000c),
+tregister($040D000d),
+tregister($040D000e),
+tregister($040D000f)
diff --git a/compiler/x86_64/r8664op.inc b/compiler/x86_64/r8664op.inc
index 2681385b44..af3878d4d3 100644
--- a/compiler/x86_64/r8664op.inc
+++ b/compiler/x86_64/r8664op.inc
@@ -123,4 +123,20 @@
 4,
 5,
 6,
+7,
+0,
+1,
+2,
+3,
+4,
+5,
+6,
+7,
+0,
+1,
+2,
+3,
+4,
+5,
+6,
 7
diff --git a/compiler/x86_64/r8664ot.inc b/compiler/x86_64/r8664ot.inc
index 7db67465fe..5cf3af7cd3 100644
--- a/compiler/x86_64/r8664ot.inc
+++ b/compiler/x86_64/r8664ot.inc
@@ -123,4 +123,20 @@ OT_XMMREG,
 OT_XMMREG,
 OT_XMMREG,
 OT_XMMREG,
-OT_XMMREG
+OT_XMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG,
+OT_YMMREG
diff --git a/compiler/x86_64/r8664rni.inc b/compiler/x86_64/r8664rni.inc
index 3ab0a735ab..f83dc7012c 100644
--- a/compiler/x86_64/r8664rni.inc
+++ b/compiler/x86_64/r8664rni.inc
@@ -101,6 +101,22 @@
 122,
 123,
 124,
+125,
+126,
+127,
+128,
+129,
+130,
+131,
+132,
+133,
+134,
+135,
+136,
+137,
+138,
+139,
+140,
 69,
 70,
 71,
diff --git a/compiler/x86_64/r8664sri.inc b/compiler/x86_64/r8664sri.inc
index 67d9df19f9..e138ae7bc3 100644
--- a/compiler/x86_64/r8664sri.inc
+++ b/compiler/x86_64/r8664sri.inc
@@ -123,4 +123,20 @@
 115,
 116,
 117,
-118
+118,
+125,
+126,
+135,
+136,
+137,
+138,
+139,
+140,
+127,
+128,
+129,
+130,
+131,
+132,
+133,
+134
diff --git a/compiler/x86_64/r8664stab.inc b/compiler/x86_64/r8664stab.inc
index 27f736cb5c..0f2b2ffe33 100644
--- a/compiler/x86_64/r8664stab.inc
+++ b/compiler/x86_64/r8664stab.inc
@@ -123,4 +123,20 @@
 29,
 30,
 31,
+32,
+17,
+18,
+19,
+20,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
+28,
+29,
+30,
+31,
 32
diff --git a/compiler/x86_64/r8664std.inc b/compiler/x86_64/r8664std.inc
index 55ea578074..25ecb9c5b1 100644
--- a/compiler/x86_64/r8664std.inc
+++ b/compiler/x86_64/r8664std.inc
@@ -123,4 +123,20 @@
 'xmm12',
 'xmm13',
 'xmm14',
-'xmm15'
+'xmm15',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7',
+'ymm8',
+'ymm9',
+'ymm10',
+'ymm11',
+'ymm12',
+'ymm13',
+'ymm14',
+'ymm15'
diff --git a/compiler/x86_64/x8664ats.inc b/compiler/x86_64/x8664ats.inc
index 31bc9cd421..2f06270fe3 100644
--- a/compiler/x86_64/x8664ats.inc
+++ b/compiler/x86_64/x8664ats.inc
@@ -417,7 +417,7 @@ attsufNONE,
 attsufNONE,
 attsufNONE,
 attsufNONE,
-attsufINT,
+attsufMM,
 attsufINT,
 attsufNONE,
 attsufINT,
@@ -534,7 +534,7 @@ attsufNONE,
 attsufNONE,
 attsufINT,
 attsufNONE,
-attsufINT,
+attsufMM,
 attsufNONE,
 attsufNONE,
 attsufNONE,
@@ -684,5 +684,264 @@ attsufNONE,
 attsufNONE,
 attsufNONE,
 attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufMM,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
+attsufNONE,
 attsufNONE
 );
diff --git a/compiler/x86_64/x8664att.inc b/compiler/x86_64/x8664att.inc
index a591dad220..14ca3fbc0b 100644
--- a/compiler/x86_64/x8664att.inc
+++ b/compiler/x86_64/x8664att.inc
@@ -684,5 +684,264 @@
 'aeskeygenassist',
 'stosq',
 'lodsq',
-'cmpsq'
+'cmpsq',
+'vaddpd',
+'vaddps',
+'vaddsd',
+'vaddss',
+'vaddsubpd',
+'vaddsubps',
+'vaesdec',
+'vaesdeclast',
+'vaesenc',
+'vaesenclast',
+'vaesimc',
+'vaeskeygenassist',
+'vandnpd',
+'vandnps',
+'vandpd',
+'vandps',
+'vblendpd',
+'vblendps',
+'vblendvpd',
+'vblendvps',
+'vbroadcastf128',
+'vbroadcastsd',
+'vbroadcastss',
+'vcmppd',
+'vcmpps',
+'vcmpsd',
+'vcmpss',
+'vcomisd',
+'vcomiss',
+'vcvtdq2pd',
+'vcvtdq2ps',
+'vcvtpd2dq',
+'vcvtpd2ps',
+'vcvtps2dq',
+'vcvtps2pd',
+'vcvtsd2si',
+'vcvtsd2ss',
+'vcvtsi2sd',
+'vcvtsi2ss',
+'vcvtss2sd',
+'vcvtss2si',
+'vcvttpd2dq',
+'vcvttps2dq',
+'vcvttsd2si',
+'vcvttss2si',
+'vdivpd',
+'vdivps',
+'vdivsd',
+'vdivss',
+'vdppd',
+'vdpps',
+'vextractf128',
+'vextractps',
+'vhaddpd',
+'vhaddps',
+'vhsubpd',
+'vhsubps',
+'vinsertf128',
+'vinsertps',
+'vlddqu',
+'vldmxcsr',
+'vmaskmovdqu',
+'vmaskmovpd',
+'vmaskmovps',
+'vmaxpd',
+'vmaxps',
+'vmaxsd',
+'vmaxss',
+'vminpd',
+'vminps',
+'vminsd',
+'vminss',
+'vmovapd',
+'vmovaps',
+'vmovd',
+'vmovddup',
+'vmovdqa',
+'vmovdqu',
+'vmovhlps',
+'vmovhpd',
+'vmovhps',
+'vmovlhps',
+'vmovlpd',
+'vmovlps',
+'vmovmskpd',
+'vmovmskps',
+'vmovntdq',
+'vmovntdqa',
+'vmovntpd',
+'vmovntps',
+'vmovq',
+'vmovsd',
+'vmovshdup',
+'vmovsldup',
+'vmovss',
+'vmovupd',
+'vmovups',
+'vmpsadbw',
+'vmulpd',
+'vmulps',
+'vmulsd',
+'vmulss',
+'vorpd',
+'vorps',
+'vpabsb',
+'vpabsd',
+'vpabsw',
+'vpackssdw',
+'vpacksswb',
+'vpackusdw',
+'vpackuswb',
+'vpaddb',
+'vpaddd',
+'vpaddq',
+'vpaddsb',
+'vpaddsw',
+'vpaddusb',
+'vpaddusw',
+'vpaddw',
+'vpalignr',
+'vpand',
+'vpandn',
+'vpavgb',
+'vpavgw',
+'vpblendvb',
+'vpblendw',
+'vpclmulqdq',
+'vpcmpeqb',
+'vpcmpeqd',
+'vpcmpeqq',
+'vpcmpeqw',
+'vpcmpestri',
+'vpcmpestrm',
+'vpcmpgtb',
+'vpcmpgtd',
+'vpcmpgtq',
+'vpcmpgtw',
+'vpcmpistri',
+'vpcmpistrm',
+'vperm2f128',
+'vpermilpd',
+'vpermilps',
+'vpextrb',
+'vpextrd',
+'vpextrq',
+'vpextrw',
+'vphaddd',
+'vphaddsw',
+'vphaddw',
+'vphminposuw',
+'vphsubd',
+'vphsubsw',
+'vphsubw',
+'vpinsrb',
+'vpinsrd',
+'vpinsrq',
+'vpinsrw',
+'vpmaddubsw',
+'vpmaddwd',
+'vpmaxsb',
+'vpmaxsd',
+'vpmaxsw',
+'vpmaxub',
+'vpmaxud',
+'vpmaxuw',
+'vpminsb',
+'vpminsd',
+'vpminsw',
+'vpminub',
+'vpminud',
+'vpminuw',
+'vpmovmskb',
+'vpmovsxbd',
+'vpmovsxbq',
+'vpmovsxbw',
+'vpmovsxdq',
+'vpmovsxwd',
+'vpmovsxwq',
+'vpmovzxbd',
+'vpmovzxbq',
+'vpmovzxbw',
+'vpmovzxdq',
+'vpmovzxwd',
+'vpmovzxwq',
+'vpmuldq',
+'vpmulhrsw',
+'vpmulhuw',
+'vpmulhw',
+'vpmulld',
+'vpmullw',
+'vpmuludq',
+'vpor',
+'vpsadbw',
+'vpshufb',
+'vpshufd',
+'vpshufhw',
+'vpshuflw',
+'vpsignb',
+'vpsignd',
+'vpsignw',
+'vpslld',
+'vpslldq',
+'vpsllq',
+'vpsllw',
+'vpsrad',
+'vpsraw',
+'vpsrld',
+'vpsrldq',
+'vpsrlq',
+'vpsrlw',
+'vpsubb',
+'vpsubd',
+'vpsubq',
+'vpsubsb',
+'vpsubsw',
+'vpsubusb',
+'vpsubusw',
+'vpsubw',
+'vptest',
+'vpunpckhbw',
+'vpunpckhdq',
+'vpunpckhqdq',
+'vpunpckhwd',
+'vpunpcklbw',
+'vpunpckldq',
+'vpunpcklqdq',
+'vpunpcklwd',
+'vpxor',
+'vrcpps',
+'vrcpss',
+'vroundpd',
+'vroundps',
+'vroundsd',
+'vroundss',
+'vrsqrtps',
+'vrsqrtss',
+'vshufpd',
+'vshufps',
+'vsqrtpd',
+'vsqrtps',
+'vsqrtsd',
+'vsqrtss',
+'vstmxcsr',
+'vsubpd',
+'vsubps',
+'vsubsd',
+'vsubss',
+'vtestpd',
+'vtestps',
+'vucomisd',
+'vucomiss',
+'vunpckhpd',
+'vunpckhps',
+'vunpcklpd',
+'vunpcklps',
+'vxorpd',
+'vxorps',
+'vzeroall',
+'vzeroupper'
 );
diff --git a/compiler/x86_64/x8664int.inc b/compiler/x86_64/x8664int.inc
index b6cc4caa78..3a3f4b4631 100644
--- a/compiler/x86_64/x8664int.inc
+++ b/compiler/x86_64/x8664int.inc
@@ -684,5 +684,264 @@
 'aeskeygenassist',
 'stosq',
 'lodsq',
-'cmpsq'
+'cmpsq',
+'vaddpd',
+'vaddps',
+'vaddsd',
+'vaddss',
+'vaddsubpd',
+'vaddsubps',
+'vaesdec',
+'vaesdeclast',
+'vaesenc',
+'vaesenclast',
+'vaesimc',
+'vaeskeygenassist',
+'vandnpd',
+'vandnps',
+'vandpd',
+'vandps',
+'vblendpd',
+'vblendps',
+'vblendvpd',
+'vblendvps',
+'vbroadcastf128',
+'vbroadcastsd',
+'vbroadcastss',
+'vcmppd',
+'vcmpps',
+'vcmpsd',
+'vcmpss',
+'vcomisd',
+'vcomiss',
+'vcvtdq2pd',
+'vcvtdq2ps',
+'vcvtpd2dq',
+'vcvtpd2ps',
+'vcvtps2dq',
+'vcvtps2pd',
+'vcvtsd2si',
+'vcvtsd2ss',
+'vcvtsi2sd',
+'vcvtsi2ss',
+'vcvtss2sd',
+'vcvtss2si',
+'vcvttpd2dq',
+'vcvttps2dq',
+'vcvttsd2si',
+'vcvttss2si',
+'vdivpd',
+'vdivps',
+'vdivsd',
+'vdivss',
+'vdppd',
+'vdpps',
+'vextractf128',
+'vextractps',
+'vhaddpd',
+'vhaddps',
+'vhsubpd',
+'vhsubps',
+'vinsertf128',
+'vinsertps',
+'vlddqu',
+'vldmxcsr',
+'vmaskmovdqu',
+'vmaskmovpd',
+'vmaskmovps',
+'vmaxpd',
+'vmaxps',
+'vmaxsd',
+'vmaxss',
+'vminpd',
+'vminps',
+'vminsd',
+'vminss',
+'vmovapd',
+'vmovaps',
+'vmovd',
+'vmovddup',
+'vmovdqa',
+'vmovdqu',
+'vmovhlps',
+'vmovhpd',
+'vmovhps',
+'vmovlhps',
+'vmovlpd',
+'vmovlps',
+'vmovmskpd',
+'vmovmskps',
+'vmovntdq',
+'vmovntdqa',
+'vmovntpd',
+'vmovntps',
+'vmovq',
+'vmovsd',
+'vmovshdup',
+'vmovsldup',
+'vmovss',
+'vmovupd',
+'vmovups',
+'vmpsadbw',
+'vmulpd',
+'vmulps',
+'vmulsd',
+'vmulss',
+'vorpd',
+'vorps',
+'vpabsb',
+'vpabsd',
+'vpabsw',
+'vpackssdw',
+'vpacksswb',
+'vpackusdw',
+'vpackuswb',
+'vpaddb',
+'vpaddd',
+'vpaddq',
+'vpaddsb',
+'vpaddsw',
+'vpaddusb',
+'vpaddusw',
+'vpaddw',
+'vpalignr',
+'vpand',
+'vpandn',
+'vpavgb',
+'vpavgw',
+'vpblendvb',
+'vpblendw',
+'vpclmulqdq',
+'vpcmpeqb',
+'vpcmpeqd',
+'vpcmpeqq',
+'vpcmpeqw',
+'vpcmpestri',
+'vpcmpestrm',
+'vpcmpgtb',
+'vpcmpgtd',
+'vpcmpgtq',
+'vpcmpgtw',
+'vpcmpistri',
+'vpcmpistrm',
+'vperm2f128',
+'vpermilpd',
+'vpermilps',
+'vpextrb',
+'vpextrd',
+'vpextrq',
+'vpextrw',
+'vphaddd',
+'vphaddsw',
+'vphaddw',
+'vphminposuw',
+'vphsubd',
+'vphsubsw',
+'vphsubw',
+'vpinsrb',
+'vpinsrd',
+'vpinsrq',
+'vpinsrw',
+'vpmaddubsw',
+'vpmaddwd',
+'vpmaxsb',
+'vpmaxsd',
+'vpmaxsw',
+'vpmaxub',
+'vpmaxud',
+'vpmaxuw',
+'vpminsb',
+'vpminsd',
+'vpminsw',
+'vpminub',
+'vpminud',
+'vpminuw',
+'vpmovmskb',
+'vpmovsxbd',
+'vpmovsxbq',
+'vpmovsxbw',
+'vpmovsxdq',
+'vpmovsxwd',
+'vpmovsxwq',
+'vpmovzxbd',
+'vpmovzxbq',
+'vpmovzxbw',
+'vpmovzxdq',
+'vpmovzxwd',
+'vpmovzxwq',
+'vpmuldq',
+'vpmulhrsw',
+'vpmulhuw',
+'vpmulhw',
+'vpmulld',
+'vpmullw',
+'vpmuludq',
+'vpor',
+'vpsadbw',
+'vpshufb',
+'vpshufd',
+'vpshufhw',
+'vpshuflw',
+'vpsignb',
+'vpsignd',
+'vpsignw',
+'vpslld',
+'vpslldq',
+'vpsllq',
+'vpsllw',
+'vpsrad',
+'vpsraw',
+'vpsrld',
+'vpsrldq',
+'vpsrlq',
+'vpsrlw',
+'vpsubb',
+'vpsubd',
+'vpsubq',
+'vpsubsb',
+'vpsubsw',
+'vpsubusb',
+'vpsubusw',
+'vpsubw',
+'vptest',
+'vpunpckhbw',
+'vpunpckhdq',
+'vpunpckhqdq',
+'vpunpckhwd',
+'vpunpcklbw',
+'vpunpckldq',
+'vpunpcklqdq',
+'vpunpcklwd',
+'vpxor',
+'vrcpps',
+'vrcpss',
+'vroundpd',
+'vroundps',
+'vroundsd',
+'vroundss',
+'vrsqrtps',
+'vrsqrtss',
+'vshufpd',
+'vshufps',
+'vsqrtpd',
+'vsqrtps',
+'vsqrtsd',
+'vsqrtss',
+'vstmxcsr',
+'vsubpd',
+'vsubps',
+'vsubsd',
+'vsubss',
+'vtestpd',
+'vtestps',
+'vucomisd',
+'vucomiss',
+'vunpckhpd',
+'vunpckhps',
+'vunpcklpd',
+'vunpcklps',
+'vxorpd',
+'vxorps',
+'vzeroall',
+'vzeroupper'
 );
diff --git a/compiler/x86_64/x8664nop.inc b/compiler/x86_64/x8664nop.inc
index c2713bb5c9..d666800c80 100644
--- a/compiler/x86_64/x8664nop.inc
+++ b/compiler/x86_64/x8664nop.inc
@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86ins.dat }
-1219;
+1667;
diff --git a/compiler/x86_64/x8664op.inc b/compiler/x86_64/x8664op.inc
index 4070734e54..fbbb16b8c6 100644
--- a/compiler/x86_64/x8664op.inc
+++ b/compiler/x86_64/x8664op.inc
@@ -684,5 +684,264 @@ A_AESIMC,
 A_AESKEYGENASSIST,
 A_STOSQ,
 A_LODSQ,
-A_CMPSQ
+A_CMPSQ,
+A_VADDPD,
+A_VADDPS,
+A_VADDSD,
+A_VADDSS,
+A_VADDSUBPD,
+A_VADDSUBPS,
+A_VAESDEC,
+A_VAESDECLAST,
+A_VAESENC,
+A_VAESENCLAST,
+A_VAESIMC,
+A_VAESKEYGENASSIST,
+A_VANDNPD,
+A_VANDNPS,
+A_VANDPD,
+A_VANDPS,
+A_VBLENDPD,
+A_VBLENDPS,
+A_VBLENDVPD,
+A_VBLENDVPS,
+A_VBROADCASTF128,
+A_VBROADCASTSD,
+A_VBROADCASTSS,
+A_VCMPPD,
+A_VCMPPS,
+A_VCMPSD,
+A_VCMPSS,
+A_VCOMISD,
+A_VCOMISS,
+A_VCVTDQ2PD,
+A_VCVTDQ2PS,
+A_VCVTPD2DQ,
+A_VCVTPD2PS,
+A_VCVTPS2DQ,
+A_VCVTPS2PD,
+A_VCVTSD2SI,
+A_VCVTSD2SS,
+A_VCVTSI2SD,
+A_VCVTSI2SS,
+A_VCVTSS2SD,
+A_VCVTSS2SI,
+A_VCVTTPD2DQ,
+A_VCVTTPS2DQ,
+A_VCVTTSD2SI,
+A_VCVTTSS2SI,
+A_VDIVPD,
+A_VDIVPS,
+A_VDIVSD,
+A_VDIVSS,
+A_VDPPD,
+A_VDPPS,
+A_VEXTRACTF128,
+A_VEXTRACTPS,
+A_VHADDPD,
+A_VHADDPS,
+A_VHSUBPD,
+A_VHSUBPS,
+A_VINSERTF128,
+A_VINSERTPS,
+A_VLDDQU,
+A_VLDMXCSR,
+A_VMASKMOVDQU,
+A_VMASKMOVPD,
+A_VMASKMOVPS,
+A_VMAXPD,
+A_VMAXPS,
+A_VMAXSD,
+A_VMAXSS,
+A_VMINPD,
+A_VMINPS,
+A_VMINSD,
+A_VMINSS,
+A_VMOVAPD,
+A_VMOVAPS,
+A_VMOVD,
+A_VMOVDDUP,
+A_VMOVDQA,
+A_VMOVDQU,
+A_VMOVHLPS,
+A_VMOVHPD,
+A_VMOVHPS,
+A_VMOVLHPS,
+A_VMOVLPD,
+A_VMOVLPS,
+A_VMOVMSKPD,
+A_VMOVMSKPS,
+A_VMOVNTDQ,
+A_VMOVNTDQA,
+A_VMOVNTPD,
+A_VMOVNTPS,
+A_VMOVQ,
+A_VMOVSD,
+A_VMOVSHDUP,
+A_VMOVSLDUP,
+A_VMOVSS,
+A_VMOVUPD,
+A_VMOVUPS,
+A_VMPSADBW,
+A_VMULPD,
+A_VMULPS,
+A_VMULSD,
+A_VMULSS,
+A_VORPD,
+A_VORPS,
+A_VPABSB,
+A_VPABSD,
+A_VPABSW,
+A_VPACKSSDW,
+A_VPACKSSWB,
+A_VPACKUSDW,
+A_VPACKUSWB,
+A_VPADDB,
+A_VPADDD,
+A_VPADDQ,
+A_VPADDSB,
+A_VPADDSW,
+A_VPADDUSB,
+A_VPADDUSW,
+A_VPADDW,
+A_VPALIGNR,
+A_VPAND,
+A_VPANDN,
+A_VPAVGB,
+A_VPAVGW,
+A_VPBLENDVB,
+A_VPBLENDW,
+A_VPCLMULQDQ,
+A_VPCMPEQB,
+A_VPCMPEQD,
+A_VPCMPEQQ,
+A_VPCMPEQW,
+A_VPCMPESTRI,
+A_VPCMPESTRM,
+A_VPCMPGTB,
+A_VPCMPGTD,
+A_VPCMPGTQ,
+A_VPCMPGTW,
+A_VPCMPISTRI,
+A_VPCMPISTRM,
+A_VPERM2F128,
+A_VPERMILPD,
+A_VPERMILPS,
+A_VPEXTRB,
+A_VPEXTRD,
+A_VPEXTRQ,
+A_VPEXTRW,
+A_VPHADDD,
+A_VPHADDSW,
+A_VPHADDW,
+A_VPHMINPOSUW,
+A_VPHSUBD,
+A_VPHSUBSW,
+A_VPHSUBW,
+A_VPINSRB,
+A_VPINSRD,
+A_VPINSRQ,
+A_VPINSRW,
+A_VPMADDUBSW,
+A_VPMADDWD,
+A_VPMAXSB,
+A_VPMAXSD,
+A_VPMAXSW,
+A_VPMAXUB,
+A_VPMAXUD,
+A_VPMAXUW,
+A_VPMINSB,
+A_VPMINSD,
+A_VPMINSW,
+A_VPMINUB,
+A_VPMINUD,
+A_VPMINUW,
+A_VPMOVMSKB,
+A_VPMOVSXBD,
+A_VPMOVSXBQ,
+A_VPMOVSXBW,
+A_VPMOVSXDQ,
+A_VPMOVSXWD,
+A_VPMOVSXWQ,
+A_VPMOVZXBD,
+A_VPMOVZXBQ,
+A_VPMOVZXBW,
+A_VPMOVZXDQ,
+A_VPMOVZXWD,
+A_VPMOVZXWQ,
+A_VPMULDQ,
+A_VPMULHRSW,
+A_VPMULHUW,
+A_VPMULHW,
+A_VPMULLD,
+A_VPMULLW,
+A_VPMULUDQ,
+A_VPOR,
+A_VPSADBW,
+A_VPSHUFB,
+A_VPSHUFD,
+A_VPSHUFHW,
+A_VPSHUFLW,
+A_VPSIGNB,
+A_VPSIGND,
+A_VPSIGNW,
+A_VPSLLD,
+A_VPSLLDQ,
+A_VPSLLQ,
+A_VPSLLW,
+A_VPSRAD,
+A_VPSRAW,
+A_VPSRLD,
+A_VPSRLDQ,
+A_VPSRLQ,
+A_VPSRLW,
+A_VPSUBB,
+A_VPSUBD,
+A_VPSUBQ,
+A_VPSUBSB,
+A_VPSUBSW,
+A_VPSUBUSB,
+A_VPSUBUSW,
+A_VPSUBW,
+A_VPTEST,
+A_VPUNPCKHBW,
+A_VPUNPCKHDQ,
+A_VPUNPCKHQDQ,
+A_VPUNPCKHWD,
+A_VPUNPCKLBW,
+A_VPUNPCKLDQ,
+A_VPUNPCKLQDQ,
+A_VPUNPCKLWD,
+A_VPXOR,
+A_VRCPPS,
+A_VRCPSS,
+A_VROUNDPD,
+A_VROUNDPS,
+A_VROUNDSD,
+A_VROUNDSS,
+A_VRSQRTPS,
+A_VRSQRTSS,
+A_VSHUFPD,
+A_VSHUFPS,
+A_VSQRTPD,
+A_VSQRTPS,
+A_VSQRTSD,
+A_VSQRTSS,
+A_VSTMXCSR,
+A_VSUBPD,
+A_VSUBPS,
+A_VSUBSD,
+A_VSUBSS,
+A_VTESTPD,
+A_VTESTPS,
+A_VUCOMISD,
+A_VUCOMISS,
+A_VUNPCKHPD,
+A_VUNPCKHPS,
+A_VUNPCKLPD,
+A_VUNPCKLPS,
+A_VXORPD,
+A_VXORPS,
+A_VZEROALL,
+A_VZEROUPPER
 );
diff --git a/compiler/x86_64/x8664pro.inc b/compiler/x86_64/x8664pro.inc
index 4a8f2f7fa4..e57a923f65 100644
--- a/compiler/x86_64/x8664pro.inc
+++ b/compiler/x86_64/x8664pro.inc
@@ -684,5 +684,264 @@
 (Ch: (Ch_All, Ch_None, Ch_None)),
 (Ch: (Ch_RRAX, Ch_WMemEDI, Ch_RWRDI)),
 (Ch: (Ch_WRAX, Ch_RWRSI, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
+(Ch: (Ch_All, Ch_None, Ch_None)),
 (Ch: (Ch_All, Ch_None, Ch_None))
 );
diff --git a/compiler/x86_64/x8664tab.inc b/compiler/x86_64/x8664tab.inc
index 5a89969928..e978b44df8 100644
--- a/compiler/x86_64/x8664tab.inc
+++ b/compiler/x86_64/x8664tab.inc
@@ -3944,7 +3944,7 @@
   (
     opcode  : A_POR;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
     code    : #241#2#15#235#72;
     flags   : if_willamette or if_sse2 or if_sm
   ),
@@ -6086,21 +6086,14 @@
   (
     opcode  : A_CVTPI2PS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
-    code    : #217#2#15#42#72;
-    flags   : if_katmai or if_sse or if_mmx
-  ),
-  (
-    opcode  : A_CVTPI2PS;
-    ops     : 2;
-    optypes : (ot_xmmreg,ot_mmxreg,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_mmxrm,ot_none,ot_none);
     code    : #217#2#15#42#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
   (
     opcode  : A_CVTPS2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #217#2#15#45#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
@@ -6114,21 +6107,21 @@
   (
     opcode  : A_CVTSI2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
     code    : #219#209#2#15#42#72;
     flags   : if_katmai or if_sse
   ),
   (
     opcode  : A_CVTSI2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none);
     code    : #219#209#2#15#42#72;
-    flags   : if_katmai or if_sse
+    flags   : if_katmai or if_sse or if_x86_64 or if_si
   ),
   (
     opcode  : A_CVTSS2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none);
     code    : #219#208#2#15#45#72;
     flags   : if_katmai or if_sse
   ),
@@ -6142,7 +6135,7 @@
   (
     opcode  : A_CVTTPS2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #217#2#15#44#72;
     flags   : if_katmai or if_sse or if_mmx
   ),
@@ -6156,7 +6149,7 @@
   (
     opcode  : A_CVTTSS2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none);
     code    : #219#208#2#15#44#72;
     flags   : if_katmai or if_sse
   ),
@@ -7087,7 +7080,14 @@
   (
     opcode  : A_CVTDQ2PD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #219#2#15#230#72;
+    flags   : if_willamette or if_sse2
+  ),
+  (
+    opcode  : A_CVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #219#2#15#230#72;
     flags   : if_willamette or if_sse2
   ),
@@ -7136,63 +7136,91 @@
   (
     opcode  : A_CVTPS2PD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #2#15#90#72;
+    flags   : if_willamette or if_sse2
+  ),
+  (
+    opcode  : A_CVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_xmmreg,ot_none,ot_none);
-    code    : #220#208#2#15#45#72;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#2#15#45#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#2#15#45#72;
+    flags   : if_willamette or if_sse2
+  ),
+  (
+    opcode  : A_CVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
     code    : #220#208#2#15#45#72;
+    flags   : if_willamette or if_sse2 or if_x86_64
+  ),
+  (
+    opcode  : A_CVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#208#2#15#45#72;
+    flags   : if_willamette or if_sse2 or if_x86_64
+  ),
+  (
+    opcode  : A_CVTSD2SS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #220#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSD2SS;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #220#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSI2SD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none);
-    code    : #220#209#2#15#42#72;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
+    code    : #220#2#15#42#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTSI2SD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_memory,ot_none,ot_none);
-    code    : #220#209#2#15#42#72;
-    flags   : if_willamette or if_sse2
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none);
+    code    : #214#220#209#2#15#42#72;
+    flags   : if_willamette or if_sse2 or if_x86_64 or if_si
   ),
   (
     opcode  : A_CVTSS2SD;
     ops     : 2;
-    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
     code    : #219#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
-    opcode  : A_CVTTPD2PI;
+    opcode  : A_CVTSS2SD;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_xmmreg,ot_none,ot_none);
-    code    : #241#2#15#44#72;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#2#15#90#72;
     flags   : if_willamette or if_sse2
   ),
   (
     opcode  : A_CVTTPD2PI;
     ops     : 2;
-    optypes : (ot_mmxreg,ot_memory,ot_none,ot_none);
+    optypes : (ot_mmxreg,ot_xmmrm,ot_none,ot_none);
     code    : #241#2#15#44#72;
     flags   : if_willamette or if_sse2
   ),
@@ -7220,7 +7248,7 @@
   (
     opcode  : A_CVTTSD2SI;
     ops     : 2;
-    optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none);
+    optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits64,ot_none,ot_none);
     code    : #220#208#2#15#44#72;
     flags   : if_willamette or if_sse2
   ),
@@ -8532,5 +8560,3113 @@
     optypes : (ot_none,ot_none,ot_none,ot_none);
     code    : #214#1#167;
     flags   : if_x86_64
+  ),
+  (
+    opcode  : A_VADDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#88#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VADDSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#208#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESDEC;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#222#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESDECLAST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#223#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESENC;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#220#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESENCLAST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#221#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESIMC;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#219#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VAESKEYGENASSIST;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#223#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDNPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#85#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VANDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#84#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#13#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#13#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#12#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#12#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#75#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg);
+    code    : #241#242#244#250#1#75#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#74#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBLENDVPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg);
+    code    : #241#242#244#250#1#74#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTF128;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #241#242#244#249#1#26#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#244#249#1#25#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#244#249#1#24#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VBROADCASTSS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#24#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #242#244#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #220#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #220#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #219#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCMPSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #219#242#248#1#194#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#47#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #219#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_none,ot_none);
+    code    : #219#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #219#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTDQ2PS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #220#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #220#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#90#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPD2PS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#90#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTPS2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2DQ;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #242#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTPS2PD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#244#248#1#90#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSD2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSI2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none);
+    code    : #220#242#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_sd or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none);
+    code    : #220#242#243#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none);
+    code    : #219#242#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_sd or if_si
+  ),
+  (
+    opcode  : A_VCVTSI2SS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none);
+    code    : #219#242#243#248#1#42#61#80;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTSS2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#90#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#243#248#1#45#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTTPD2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#230#72;
+    flags   : if_avx or if_sandybridge or if_si
+  ),
+  (
+    opcode  : A_VCVTTPS2DQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTPS2DQ;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#91#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSD2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #219#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VCVTTSS2SI;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#243#248#1#44#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDIVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#94#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#65#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#64#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VDPPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#64#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VEXTRACTF128;
+    ops     : 3;
+    optypes : (ot_xmmrm,ot_ymmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#25#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VEXTRACTPS;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#23#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHADDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#124#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #220#242#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VHSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #220#242#244#248#1#125#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTF128;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#24#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#33#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VINSERTPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#33#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #220#242#248#1#240#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDDQU;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_memory or ot_bits256,ot_none,ot_none);
+    code    : #220#242#244#248#1#240#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VLDMXCSR;
+    ops     : 1;
+    optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none);
+    code    : #242#248#1#174#130;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#247#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none);
+    code    : #241#242#244#249#1#47#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #241#242#249#1#47#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none);
+    code    : #241#242#244#249#1#45#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none);
+    code    : #241#242#249#1#45#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none);
+    code    : #241#242#244#249#1#46#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #241#242#249#1#46#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none);
+    code    : #241#242#244#249#1#44#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMASKMOVPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none);
+    code    : #241#242#249#1#44#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMAXSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#95#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMINSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#93#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPD;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#40#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVAPS;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#41#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none);
+    code    : #241#242#248#1#110#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVD;
+    ops     : 2;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#126#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #220#242#244#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQA;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#111#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVDQU;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #219#242#244#248#1#127#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#23#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #241#242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVHPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#23#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #242#248#1#22#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#19#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #241#242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#19#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #242#248#1#18#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPD;
+    ops     : 2;
+    optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVMSKPS;
+    ops     : 2;
+    optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#80#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQ;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#231#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQ;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#231#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTDQA;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none);
+    code    : #241#242#249#1#42#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVNTPS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#43#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVQ;
+    ops     : 2;
+    optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#243#248#1#126#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none);
+    code    : #241#242#243#248#1#110#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#16#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #220#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#17#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSD;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #220#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSHDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#22#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSHDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#22#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSLDUP;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #219#242#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSLDUP;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #219#242#244#248#1#18#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#16#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #219#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#17#61#66;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVSS;
+    ops     : 2;
+    optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none);
+    code    : #219#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPD;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #241#242#244#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#16#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMOVUPS;
+    ops     : 2;
+    optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none);
+    code    : #242#244#248#1#17#65;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMPSADBW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#66#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VMULSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#89#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VORPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#86#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSB;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#28#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#30#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPABSW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#29#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKSSDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#107#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKSSWB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#99#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKUSDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#43#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPACKUSWB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#103#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#252#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#254#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#212#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#236#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#237#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDUSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#220#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDUSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#221#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPADDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#253#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPALIGNR;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#15#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAND;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#219#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPANDN;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#223#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAVGB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#224#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPAVGW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#227#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPBLENDVB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg);
+    code    : #241#242#250#1#76#61#80#247;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPBLENDW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#14#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCLMULQDQ;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#68#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#116#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#118#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#41#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPEQW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#117#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPESTRI;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#97#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPESTRM;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#96#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#100#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#102#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#55#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPGTW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#101#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPISTRI;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#99#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPCMPISTRM;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#98#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERM2F128;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#250#1#6#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#249#1#13#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#5#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#5#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#13#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#249#1#12#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#4#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#4#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPERMILPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#12#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRB;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits8,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#20#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRD;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#22#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRQ;
+    ops     : 3;
+    optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#243#250#1#22#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#197#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#197#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPEXTRW;
+    ops     : 3;
+    optypes : (ot_memory or ot_bits16,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#21#65#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#2#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#3#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHADDW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#1#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHMINPOSUW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#65#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#6#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#7#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPHSUBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#5#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#32#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRB;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits8,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#32#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#34#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRQ;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_immediate or ot_bits8);
+    code    : #241#242#243#250#1#34#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#196#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPINSRW;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits16,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#196#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMADDUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#4#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMADDWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#245#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#60#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#61#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#238#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#222#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#63#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMAXUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#62#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#56#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#57#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#234#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#218#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#59#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMINUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#58#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVMSKB;
+    ops     : 2;
+    optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#215#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVMSKB;
+    ops     : 2;
+    optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#215#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#33#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#33#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none);
+    code    : #241#242#249#1#34#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#34#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#32#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#32#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#37#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#37#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#35#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#35#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#36#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVSXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#36#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#49#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#49#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none);
+    code    : #241#242#249#1#50#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#50#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#48#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXBW;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#48#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#53#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXDQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#53#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#249#1#51#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#51#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #241#242#249#1#52#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMOVZXWQ;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#249#1#52#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#40#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHRSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#11#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHUW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#228#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULHW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#229#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#64#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#213#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPMULUDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#244#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPOR;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#235#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSADBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#246#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#0#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFHW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #219#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSHUFLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #220#242#248#1#112#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGNB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#8#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGND;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#10#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSIGNW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#249#1#9#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#242#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#143#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#243#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#142#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSLLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#241#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#140#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#226#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#140#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRAW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#225#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#114#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#210#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#139#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#115#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#211#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#248#1#113#60#138#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSRLW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#209#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#248#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#250#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#251#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#232#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#233#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBUSB;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#216#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBUSW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#217#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPSUBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#249#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPTEST;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#23#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPTEST;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#23#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#104#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#106#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHQDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#109#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKHWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#105#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLBW;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#96#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#98#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLQDQ;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#108#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPUNPCKLWD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#97#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VPXOR;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#239#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#83#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#83#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#83#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRCPSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#83#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#9#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#9#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#244#250#1#8#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none);
+    code    : #241#242#250#1#8#72#22;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#11#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#11#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#10#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VROUNDSS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8);
+    code    : #241#242#250#1#10#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#82#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#82#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#82#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VRSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#82#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPD;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #241#242#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPD;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #241#242#244#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPS;
+    ops     : 4;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8);
+    code    : #242#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSHUFPS;
+    ops     : 4;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8);
+    code    : #242#244#248#1#198#61#80#23;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #242#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #242#244#248#1#81#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSQRTSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#81#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSTMXCSR;
+    ops     : 1;
+    optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none);
+    code    : #242#248#1#174#131;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none);
+    code    : #220#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #220#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none);
+    code    : #219#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VSUBSS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none);
+    code    : #219#242#248#1#92#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#15#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPD;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#15#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPS;
+    ops     : 2;
+    optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none);
+    code    : #241#242#244#249#1#14#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VTESTPS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none);
+    code    : #241#242#249#1#14#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none);
+    code    : #241#242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISD;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #241#242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none);
+    code    : #242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUCOMISS;
+    ops     : 2;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none);
+    code    : #242#248#1#46#72;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKHPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#21#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VUNPCKLPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#20#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPD;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #241#242#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPD;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #241#242#244#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPS;
+    ops     : 3;
+    optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none);
+    code    : #242#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VXORPS;
+    ops     : 3;
+    optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none);
+    code    : #242#244#248#1#87#61#80;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VZEROALL;
+    ops     : 0;
+    optypes : (ot_none,ot_none,ot_none,ot_none);
+    code    : #242#244#248#1#119;
+    flags   : if_avx or if_sandybridge
+  ),
+  (
+    opcode  : A_VZEROUPPER;
+    ops     : 0;
+    optypes : (ot_none,ot_none,ot_none,ot_none);
+    code    : #242#248#1#119;
+    flags   : if_avx or if_sandybridge
   )
 );