protected-mode avx512

1 files changed, 925 insertions, 57 deletions

diff --git a/src/protected_mode/display.rs b/src/protected_mode/display.rs
index e51d2dc..f258bad 100644
--- a/src/protected_mode/display.rs
+++ b/src/protected_mode/display.rs
@@ -5,7 +5,7 @@ use core::fmt;
 use yaxpeax_arch::{Colorize, ShowContextual, NoColors, YaxColors};
 use yaxpeax_arch::display::*;
 
-use crate::protected_mode::{RegSpec, Opcode, Operand, InstDecoder, Instruction, Segment, PrefixVex, OperandSpec};
+use crate::protected_mode::{RegSpec, Opcode, Operand, MergeMode, InstDecoder, Instruction, Segment, PrefixVex, OperandSpec};
 
 impl fmt::Display for InstDecoder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -166,6 +166,44 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Operand {
             &Operand::Register(ref spec) => {
                 f.write_str(regspec_label(spec))
             }
+            &Operand::RegisterMaskMerge(ref spec, ref mask, merge_mode) => {
+                f.write_str(regspec_label(spec))?;
+                if mask.num != 0 {
+                    f.write_str("{")?;
+                    f.write_str(regspec_label(mask))?;
+                    f.write_str("}")?;
+                }
+                if let MergeMode::Zero = merge_mode {
+                    f.write_str("{z}")?;
+                }
+                Ok(())
+            }
+            &Operand::RegisterMaskMergeSae(ref spec, ref mask, merge_mode, sae_mode) => {
+                f.write_str(regspec_label(spec))?;
+                if mask.num != 0 {
+                    f.write_str("{")?;
+                    f.write_str(regspec_label(mask))?;
+                    f.write_str("}")?;
+                }
+                if let MergeMode::Zero = merge_mode {
+                    f.write_str("{z}")?;
+                }
+                f.write_str(sae_mode.label())?;
+                Ok(())
+            }
+            &Operand::RegisterMaskMergeSaeNoround(ref spec, ref mask, merge_mode) => {
+                f.write_str(regspec_label(spec))?;
+                if mask.num != 0 {
+                    f.write_str("{")?;
+                    f.write_str(regspec_label(mask))?;
+                    f.write_str("}")?;
+                }
+                if let MergeMode::Zero = merge_mode {
+                    f.write_str("{z}")?;
+                }
+                f.write_str("{sae}")?;
+                Ok(())
+            }
             &Operand::DisplacementU16(imm) => {
                 write!(f, "[{}]", colors.address(u16_hex(imm)))
             }
@@ -227,6 +265,69 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Operand {
                 format_number_i32(colors, f, disp, NumberStyleHint::HexSignedWithSignSplit)?;
                 write!(f, "]")
             },
+            &Operand::RegDispMasked(ref spec, disp, ref mask_reg) => {
+                write!(f, "[{} ", regspec_label(spec))?;
+                format_number_i32(colors, f, disp, NumberStyleHint::HexSignedWithSignSplit)?;
+                write!(f, "]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
+            &Operand::RegDerefMasked(ref spec, ref mask_reg) => {
+                f.write_str("[")?;
+                f.write_str(regspec_label(spec))?;
+                f.write_str("]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
+            &Operand::RegScaleMasked(ref spec, scale, ref mask_reg) => {
+                write!(f, "[{} * {}]",
+                    regspec_label(spec),
+                    colors.number(scale)
+                )?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
+            &Operand::RegScaleDispMasked(ref spec, scale, disp, ref mask_reg) => {
+                write!(f, "[{} * {} ",
+                    regspec_label(spec),
+                    colors.number(scale),
+                )?;
+                format_number_i32(colors, f, disp, NumberStyleHint::HexSignedWithSignSplit)?;
+                write!(f, "]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
+            &Operand::RegIndexBaseMasked(ref base, ref index, ref mask_reg) => {
+                f.write_str("[")?;
+                f.write_str(regspec_label(base))?;
+                f.write_str(" + ")?;
+                f.write_str(regspec_label(index))?;
+                f.write_str("]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            }
+            &Operand::RegIndexBaseDispMasked(ref base, ref index, disp, ref mask_reg) => {
+                write!(f, "[{} + {} ",
+                    regspec_label(base),
+                    regspec_label(index),
+                )?;
+                format_number_i32(colors, f, disp, NumberStyleHint::HexSignedWithSignSplit)?;
+                write!(f, "]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
+            &Operand::RegIndexBaseScaleMasked(ref base, ref index, scale, ref mask_reg) => {
+                write!(f, "[{} + {} * {}]",
+                    regspec_label(base),
+                    regspec_label(index),
+                    colors.number(scale)
+                )?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            }
+            &Operand::RegIndexBaseScaleDispMasked(ref base, ref index, scale, disp, ref mask_reg) => {
+                write!(f, "[{} + {} * {} ",
+                    regspec_label(base),
+                    regspec_label(index),
+                    colors.number(scale),
+                )?;
+                format_number_i32(colors, f, disp, NumberStyleHint::HexSignedWithSignSplit)?;
+                write!(f, "]")?;
+                write!(f, "{{{}}}", regspec_label(mask_reg))
+            },
             &Operand::Nothing => { Ok(()) },
         }
     }
@@ -655,6 +756,7 @@ const MNEMONICS: &[&'static str] = &[
     "xorpd",
     "vmovddup",
     "vpshuflw",
+    "vpshufhw",
     "vhaddps",
     "vhsubps",
     "vaddsubps",
@@ -826,6 +928,7 @@ const MNEMONICS: &[&'static str] = &[
     "vpabsd",
     "vpabsw",
     "vpackssdw",
+    "vpackusdw",
     "vpacksswb",
     "vpackuswb",
     "vpaddb",
@@ -837,12 +940,12 @@ const MNEMONICS: &[&'static str] = &[
     "vpaddusw",
     "vpaddw",
     "vpalignr",
-    "vandps",
     "vandpd",
-    "vorps",
+    "vandps",
     "vorpd",
-    "vandnps",
+    "vorps",
     "vandnpd",
+    "vandnps",
     "vpand",
     "vpandn",
     "vpavgb",
@@ -863,6 +966,8 @@ const MNEMONICS: &[&'static str] = &[
     "vpcmpgtd",
     "vpcmpgtq",
     "vpcmpgtw",
+    "vpcmpestri",
+    "vpcmpestrm",
     "vpcmpistri",
     "vpcmpistrm",
     "vperm2f128",
@@ -884,7 +989,7 @@ const MNEMONICS: &[&'static str] = &[
     "vphaddd",
     "vphaddsw",
     "vphaddw",
-    "vphaddubsw",
+    "vpmaddubsw",
     "vphminposuw",
     "vphsubd",
     "vphsubsw",
@@ -902,8 +1007,11 @@ const MNEMONICS: &[&'static str] = &[
     "vpmaxub",
     "vpmaxuw",
     "vpmaxud",
+    "vpminsb",
     "vpminsw",
     "vpminsd",
+    "vpminub",
+    "vpminuw",
     "vpminud",
     "vpmovmskb",
     "vpmovsxbd",
@@ -922,6 +1030,7 @@ const MNEMONICS: &[&'static str] = &[
     "vpmulhrsw",
     "vpmulhuw",
     "vpmulhw",
+    "vpmullq",
     "vpmulld",
     "vpmullw",
     "vpmuludq",
@@ -992,6 +1101,9 @@ const MNEMONICS: &[&'static str] = &[
     "vxorpd",
     "vxorps",
     "vzeroupper",
+    "vzeroall",
+    "vldmxcsr",
+    "vstmxcsr",
     "pclmulqdq",
     "aeskeygenassist",
     "aesimc",
@@ -1219,6 +1331,7 @@ const MNEMONICS: &[&'static str] = &[
     "jrcxz",
     "pusha",
     "popa",
+    "bound",
     "arpl",
     "aas",
     "aaa",
@@ -1315,6 +1428,378 @@ const MNEMONICS: &[&'static str] = &[
     // TSXLDTRK
     "xsusldtrk",
     "xresldtrk",
+
+    // AVX512F
+    "valignd",
+    "valignq",
+    "vblendmpd",
+    "vblendmps",
+    "vcompresspd",
+    "vcompressps",
+    "vcvtpd2udq",
+    "vcvttpd2udq",
+    "vcvtps2udq",
+    "vcvttps2udq",
+    "vcvtqq2pd",
+    "vcvtqq2ps",
+    "vcvtsd2usi",
+    "vcvttsd2usi",
+    "vcvtss2usi",
+    "vcvttss2usi",
+    "vcvtudq2pd",
+    "vcvtudq2ps",
+    "vcvtusi2usd",
+    "vcvtusi2uss",
+    "vexpandpd",
+    "vexpandps",
+    "vextractf32x4",
+    "vextractf64x4",
+    "vextracti32x4",
+    "vextracti64x4",
+    "vfixupimmpd",
+    "vfixupimmps",
+    "vfixupimmsd",
+    "vfixupimmss",
+    "vgetexppd",
+    "vgetexpps",
+    "vgetexpsd",
+    "vgetexpss",
+    "vgetmantpd",
+    "vgetmantps",
+    "vgetmantsd",
+    "vgetmantss",
+    "vinsertf32x4",
+    "vinsertf64x4",
+    "vinserti64x4",
+    "vmovdqa32",
+    "vmovdqa64",
+    "vmovdqu32",
+    "vmovdqu64",
+    "vpblendmd",
+    "vpblendmq",
+    "vpcmpd",
+    "vpcmpud",
+    "vpcmpq",
+    "vpcmpuq",
+    "vpcompressq",
+    "vpcompressd",
+    "vpermi2d",
+    "vpermi2q",
+    "vpermi2pd",
+    "vpermi2ps",
+    "vpermt2d",
+    "vpermt2q",
+    "vpermt2pd",
+    "vpermt2ps",
+    "vpmaxsq",
+    "vpmaxuq",
+    "vpminsq",
+    "vpminuq",
+    "vpmovsqb",
+    "vpmovusqb",
+    "vpmovsqw",
+    "vpmovusqw",
+    "vpmovsqd",
+    "vpmovusqd",
+    "vpmovsdb",
+    "vpmovusdb",
+    "vpmovsdw",
+    "vpmovusdw",
+    "vprold",
+    "vprolq",
+    "vprolvd",
+    "vprolvq",
+    "vprord",
+    "vprorq",
+    "vprorrd",
+    "vprorrq",
+    "vpscatterdd",
+    "vpscatterdq",
+    "vpscatterqd",
+    "vpscatterqq",
+    "vpsraq",
+    "vpsravq",
+    "vptestnmd",
+    "vptestnmq",
+    "vpternlogd",
+    "vpternlogq",
+    "vptestmd",
+    "vptestmq",
+    "vrcp14pd",
+    "vrcp14ps",
+    "vrcp14sd",
+    "vrcp14ss",
+    "vrndscalepd",
+    "vrndscaleps",
+    "vrndscalesd",
+    "vrndscaless",
+    "vrsqrt14pd",
+    "vrsqrt14ps",
+    "vrsqrt14sd",
+    "vrsqrt14ss",
+    "vscaledpd",
+    "vscaledps",
+    "vscaledsd",
+    "vscaledss",
+    "vscatterdd",
+    "vscatterdq",
+    "vscatterqd",
+    "vscatterqq",
+    "vshuff32x4",
+    "vshuff64x2",
+    "vshufi32x4",
+    "vshufi64x2",
+
+    // AVX512DQ
+    "vcvttpd2qq",
+    "vcvtpd2qq",
+    "vcvttpd2uqq",
+    "vcvtpd2uqq",
+    "vcvttps2qq",
+    "vcvtps2qq",
+    "vcvttps2uqq",
+    "vcvtps2uqq",
+    "vcvtuqq2pd",
+    "vcvtuqq2ps",
+    "vextractf64x2",
+    "vextracti64x2",
+    "vfpclasspd",
+    "vfpclassps",
+    "vfpclasssd",
+    "vfpclassss",
+    "vinsertf64x2",
+    "vinserti64x2",
+    "vpmovm2d",
+    "vpmovm2q",
+    "vpmovb2d",
+    "vpmovq2m",
+    "vrangepd",
+    "vrangeps",
+    "vrangesd",
+    "vrangess",
+    "vreducepd",
+    "vreduceps",
+    "vreducesd",
+    "vreducess",
+
+    // AVX512BW
+    "vdbpsadbw",
+    "vmovdqu8",
+    "vmovdqu16",
+    "vpblendmb",
+    "vpblendmw",
+    "vpcmpb",
+    "vpcmpub",
+    "vpcmpw",
+    "vpcmpuw",
+    "vpermw",
+    "vpermi2b",
+    "vpermi2w",
+    "vpmovm2b",
+    "vpmovm2w",
+    "vpmovb2m",
+    "vpmovw2m",
+    "vpmovswb",
+    "vpmovuswb",
+    "vpsllvw",
+    "vpsravw",
+    "vpsrlvw",
+    "vptestnmb",
+    "vptestnmw",
+    "vptestmb",
+    "vptestmw",
+
+    // AVX512CD
+    "vpbroadcastm",
+    "vpconflictd",
+    "vpconflictq",
+    "vplzcntd",
+    "vplzcntq",
+
+    "kunpckbw",
+    "kunpckwd",
+    "kunpckdq",
+
+    "kaddb",
+    "kandb",
+    "kandnb",
+    "kmovb",
+    "knotb",
+    "korb",
+    "kortestb",
+    "kshiftlb",
+    "kshiftrb",
+    "ktestb",
+    "kxnorb",
+    "kxorb",
+    "kaddw",
+    "kandw",
+    "kandnw",
+    "kmovw",
+    "knotw",
+    "korw",
+    "kortestw",
+    "kshiftlw",
+    "kshiftrw",
+    "ktestw",
+    "kxnorw",
+    "kxorw",
+    "kaddd",
+    "kandd",
+    "kandnd",
+    "kmovd",
+    "knotd",
+    "kord",
+    "kortestd",
+    "kshiftld",
+    "kshiftrd",
+    "ktestd",
+    "kxnord",
+    "kxord",
+    "kaddq",
+    "kandq",
+    "kandnq",
+    "kmovq",
+    "knotq",
+    "korq",
+    "kortestq",
+    "kshiftlq",
+    "kshiftrq",
+    "ktestq",
+    "kxnorq",
+    "kxorq",
+
+    // AVX512ER
+    "vexp2pd",
+    "vexp2ps",
+    "vexp2sd",
+    "vexp2ss",
+    "vrcp28pd",
+    "vrcp28ps",
+    "vrcp28sd",
+    "vrcp28ss",
+    "vrsqrt28pd",
+    "vrsqrt28ps",
+    "vrsqrt28sd",
+    "vrsqrt28ss",
+
+    // AVX512PF
+    "vgatherpf0dpd",
+    "vgatherpf0dps",
+    "vgatherpf0qpd",
+    "vgatherpf0qps",
+    "vgatherpf1dpd",
+    "vgatherpf1dps",
+    "vgatherpf1qpd",
+    "vgatherpf1qps",
+    "vscatterpf0dpd",
+    "vscatterpf0dps",
+    "vscatterpf0qpd",
+    "vscatterpf0qps",
+    "vscatterpf1dpd",
+    "vscatterpf1dps",
+    "vscatterpf1qpd",
+    "vscatterpf1qps",
+
+    // MPX
+    "bndmk",
+    "bndcl",
+    "bndcu",
+    "bndcn",
+    "bndmov",
+    "bndldx",
+    "bndstx",
+
+
+
+    "vgf2p8affineqb",
+    "vgf2p8affineinvqb",
+    "vpshrdq",
+    "vpshrdd",
+    "vpshrdw",
+    "vpshldq",
+    "vpshldd",
+    "vpshldw",
+    "vbroadcastf32x8",
+    "vbroadcastf64x4",
+    "vbroadcastf32x4",
+    "vbroadcastf64x2",
+    "vbroadcastf32x2",
+    "vbroadcasti32x8",
+    "vbroadcasti64x4",
+    "vbroadcasti32x4",
+    "vbroadcasti64x2",
+    "vbroadcasti32x2",
+    "vextracti32x8",
+    "vextractf32x8",
+    "vinserti32x8",
+    "vinsertf32x8",
+    "vinserti32x4",
+    "v4fnmaddss",
+    "v4fnmaddps",
+    "vcvtneps2bf16",
+    "v4fmaddss",
+    "v4fmaddps",
+    "vcvtne2ps2bf16",
+    "vp2intersectd",
+    "vp2intersectq",
+    "vp4dpwssds",
+    "vp4dpwssd",
+    "vpdpwssds",
+    "vpdpwssd",
+    "vpdpbusds",
+    "vdpbf16ps",
+    "vpbroadcastmw2d",
+    "vpbroadcastmb2q",
+    "vpmovd2m",
+    "vpmovqd",
+    "vpmovwb",
+    "vpmovdb",
+    "vpmovdw",
+    "vpmovqb",
+    "vpmovqw",
+    "vgf2p8mulb",
+    "vpmadd52huq",
+    "vpmadd52luq",
+    "vpshufbitqmb",
+    "vpermb",
+    "vpexpandd",
+    "vpexpandq",
+    "vpabsq",
+    "vprorvd",
+    "vprorvq",
+    "vpmultishiftqb",
+    "vpermt2b",
+    "vpermt2w",
+    "vpshrdvq",
+    "vpshrdvd",
+    "vpshrdvw",
+    "vpshldvq",
+    "vpshldvd",
+    "vpshldvw",
+    "vpcompressb",
+    "vpcompressw",
+    "vpexpandb",
+    "vpexpandw",
+    "vpopcntd",
+    "vpopcntq",
+    "vpopcntb",
+    "vpopcntw",
+    "vscalefss",
+    "vscalefsd",
+    "vscalefps",
+    "vscalefpd",
+    "vpdpbusd",
+    "vcvtusi2sd",
+    "vcvtusi2ss",
+    "vpxord",
+    "vpxorq",
+    "vpord",
+    "vporq",
+    "vpandnd",
+    "vpandnq",
+    "vpandd",
+    "vpandq",
 ];
 
 impl Opcode {
@@ -1328,6 +1813,95 @@ impl Opcode {
 impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
     fn colorize(&self, colors: &Y, out: &mut T) -> fmt::Result {
         match self {
+            Opcode::VGF2P8AFFINEQB |
+            Opcode::VGF2P8AFFINEINVQB |
+            Opcode::VPSHRDQ |
+            Opcode::VPSHRDD |
+            Opcode::VPSHRDW |
+            Opcode::VPSHLDQ |
+            Opcode::VPSHLDD |
+            Opcode::VPSHLDW |
+            Opcode::VBROADCASTF32X8 |
+            Opcode::VBROADCASTF64X4 |
+            Opcode::VBROADCASTF32X4 |
+            Opcode::VBROADCASTF64X2 |
+            Opcode::VBROADCASTF32X2 |
+            Opcode::VBROADCASTI32X8 |
+            Opcode::VBROADCASTI64X4 |
+            Opcode::VBROADCASTI32X4 |
+            Opcode::VBROADCASTI64X2 |
+            Opcode::VBROADCASTI32X2 |
+            Opcode::VEXTRACTI32X8 |
+            Opcode::VEXTRACTF32X8 |
+            Opcode::VINSERTI32X8 |
+            Opcode::VINSERTF32X8 |
+            Opcode::VINSERTI32X4 |
+            Opcode::V4FNMADDSS |
+            Opcode::V4FNMADDPS |
+            Opcode::VCVTNEPS2BF16 |
+            Opcode::V4FMADDSS |
+            Opcode::V4FMADDPS |
+            Opcode::VCVTNE2PS2BF16 |
+            Opcode::VP2INTERSECTD |
+            Opcode::VP2INTERSECTQ |
+            Opcode::VP4DPWSSDS |
+            Opcode::VP4DPWSSD |
+            Opcode::VPDPWSSDS |
+            Opcode::VPDPWSSD |
+            Opcode::VPDPBUSDS |
+            Opcode::VDPBF16PS |
+            Opcode::VPBROADCASTMW2D |
+            Opcode::VPBROADCASTMB2Q |
+            Opcode::VPMOVD2M |
+            Opcode::VPMOVQD |
+            Opcode::VPMOVWB |
+            Opcode::VPMOVDB |
+            Opcode::VPMOVDW |
+            Opcode::VPMOVQB |
+            Opcode::VPMOVQW |
+            Opcode::VGF2P8MULB |
+            Opcode::VPMADD52HUQ |
+            Opcode::VPMADD52LUQ |
+            Opcode::VPSHUFBITQMB |
+            Opcode::VPERMB |
+            Opcode::VPEXPANDD |
+            Opcode::VPEXPANDQ |
+            Opcode::VPABSQ |
+            Opcode::VPRORVD |
+            Opcode::VPRORVQ |
+            Opcode::VPMULTISHIFTQB |
+            Opcode::VPERMT2B |
+            Opcode::VPERMT2W |
+            Opcode::VPSHRDVQ |
+            Opcode::VPSHRDVD |
+            Opcode::VPSHRDVW |
+            Opcode::VPSHLDVQ |
+            Opcode::VPSHLDVD |
+            Opcode::VPSHLDVW |
+            Opcode::VPCOMPRESSB |
+            Opcode::VPCOMPRESSW |
+            Opcode::VPEXPANDB |
+            Opcode::VPEXPANDW |
+            Opcode::VPOPCNTD |
+            Opcode::VPOPCNTQ |
+            Opcode::VPOPCNTB |
+            Opcode::VPOPCNTW |
+            Opcode::VSCALEFSS |
+            Opcode::VSCALEFSD |
+            Opcode::VSCALEFPS |
+            Opcode::VSCALEFPD |
+            Opcode::VPDPBUSD |
+            Opcode::VCVTUSI2SD |
+            Opcode::VCVTUSI2SS |
+            Opcode::VPXORD |
+            Opcode::VPXORQ |
+            Opcode::VPORD |
+            Opcode::VPORQ |
+            Opcode::VPANDND |
+            Opcode::VPANDNQ |
+            Opcode::VPANDD |
+            Opcode::VPANDQ |
+
             Opcode::VHADDPS |
             Opcode::VHSUBPS |
             Opcode::VADDSUBPS |
@@ -1434,6 +2008,7 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPMULHRSW |
             Opcode::VPMULHUW |
             Opcode::VPMULHW |
+            Opcode::VPMULLQ |
             Opcode::VPMULLD |
             Opcode::VPMULLW |
             Opcode::VPMULUDQ |
@@ -1451,6 +2026,34 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPSUBW |
             Opcode::VROUNDPD |
             Opcode::VROUNDPS |
+            Opcode::VEXP2PD |
+            Opcode::VEXP2PS |
+            Opcode::VEXP2SD |
+            Opcode::VEXP2SS |
+            Opcode::VRCP28PD |
+            Opcode::VRCP28PS |
+            Opcode::VRCP28SD |
+            Opcode::VRCP28SS |
+            Opcode::VRCP14PD |
+            Opcode::VRCP14PS |
+            Opcode::VRCP14SD |
+            Opcode::VRCP14SS |
+            Opcode::VRNDSCALEPD |
+            Opcode::VRNDSCALEPS |
+            Opcode::VRNDSCALESD |
+            Opcode::VRNDSCALESS |
+            Opcode::VRSQRT14PD |
+            Opcode::VRSQRT14PS |
+            Opcode::VRSQRT14SD |
+            Opcode::VRSQRT14SS |
+            Opcode::VSCALEDPD |
+            Opcode::VSCALEDPS |
+            Opcode::VSCALEDSD |
+            Opcode::VSCALEDSS |
+            Opcode::VRSQRT28PD |
+            Opcode::VRSQRT28PS |
+            Opcode::VRSQRT28SD |
+            Opcode::VRSQRT28SS |
             Opcode::VRSQRTPS |
             Opcode::VSQRTPD |
             Opcode::VSQRTPS |
@@ -1470,13 +2073,14 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VSQRTSS |
             Opcode::VPSADBW |
             Opcode::VMPSADBW |
+            Opcode::VDBPSADBW |
             Opcode::VPHADDD |
             Opcode::VPHADDSW |
             Opcode::VPHADDW |
             Opcode::VPHSUBD |
             Opcode::VPHSUBSW |
             Opcode::VPHSUBW |
-            Opcode::VPHADDUBSW |
+            Opcode::VPMADDUBSW |
             Opcode::VPMADDWD |
             Opcode::VDPPD |
             Opcode::VDPPS |
@@ -1499,6 +2103,19 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPSLLVD |
             Opcode::VPSLLVQ |
             Opcode::VPSLLW |
+            Opcode::VPROLD |
+            Opcode::VPROLQ |
+            Opcode::VPROLVD |
+            Opcode::VPROLVQ |
+            Opcode::VPRORD |
+            Opcode::VPRORQ |
+            Opcode::VPRORRD |
+            Opcode::VPRORRQ |
+            Opcode::VPSLLVW |
+            Opcode::VPSRAQ |
+            Opcode::VPSRAVQ |
+            Opcode::VPSRAVW |
+            Opcode::VPSRLVW |
             Opcode::VPSRAD |
             Opcode::VPSRAVD |
             Opcode::VPSRAW |
@@ -1584,6 +2201,8 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::SUB |
             Opcode::POPCNT |
             Opcode::LZCNT |
+            Opcode::VPLZCNTD |
+            Opcode::VPLZCNTQ |
             Opcode::BT |
             Opcode::BTS |
             Opcode::BTR |
@@ -1702,12 +2321,48 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::FXTRACT |
             Opcode::FYL2X |
             Opcode::FYL2XP1 |
-            Opcode::AAS |
             Opcode::AAA |
+            Opcode::AAS |
             Opcode::DAS |
             Opcode::DAA |
             Opcode::ADX |
             Opcode::AMX |
+            Opcode::KADDB |
+            Opcode::KANDB |
+            Opcode::KANDNB |
+            Opcode::KNOTB |
+            Opcode::KORB |
+            Opcode::KSHIFTLB |
+            Opcode::KSHIFTRB |
+            Opcode::KXNORB |
+            Opcode::KXORB |
+            Opcode::KADDW |
+            Opcode::KANDW |
+            Opcode::KANDNW |
+            Opcode::KNOTW |
+            Opcode::KORW |
+            Opcode::KSHIFTLW |
+            Opcode::KSHIFTRW |
+            Opcode::KXNORW |
+            Opcode::KXORW |
+            Opcode::KADDD |
+            Opcode::KANDD |
+            Opcode::KANDND |
+            Opcode::KNOTD |
+            Opcode::KORD |
+            Opcode::KSHIFTLD |
+            Opcode::KSHIFTRD |
+            Opcode::KXNORD |
+            Opcode::KXORD |
+            Opcode::KADDQ |
+            Opcode::KANDQ |
+            Opcode::KANDNQ |
+            Opcode::KNOTQ |
+            Opcode::KORQ |
+            Opcode::KSHIFTLQ |
+            Opcode::KSHIFTRQ |
+            Opcode::KXNORQ |
+            Opcode::KXORQ |
             Opcode::IMUL => { write!(out, "{}", colors.arithmetic_op(self)) }
             Opcode::POPF |
             Opcode::PUSHF |
@@ -1786,12 +2441,43 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VCVTSS2SI |
             Opcode::VCVTTSD2SI |
             Opcode::VCVTTSS2SI |
+            Opcode::VCVTPD2UDQ |
+            Opcode::VCVTTPD2UDQ |
+            Opcode::VCVTPS2UDQ |
+            Opcode::VCVTTPS2UDQ |
+            Opcode::VCVTQQ2PD |
+            Opcode::VCVTQQ2PS |
+            Opcode::VCVTSD2USI |
+            Opcode::VCVTTSD2USI |
+            Opcode::VCVTSS2USI |
+            Opcode::VCVTTSS2USI |
+            Opcode::VCVTUDQ2PD |
+            Opcode::VCVTUDQ2PS |
+            Opcode::VCVTUSI2USD |
+            Opcode::VCVTUSI2USS |
+            Opcode::VCVTTPD2QQ |
+            Opcode::VCVTPD2QQ |
+            Opcode::VCVTTPD2UQQ |
+            Opcode::VCVTPD2UQQ |
+            Opcode::VCVTTPS2QQ |
+            Opcode::VCVTPS2QQ |
+            Opcode::VCVTTPS2UQQ |
+            Opcode::VCVTPS2UQQ |
+            Opcode::VCVTUQQ2PD |
+            Opcode::VCVTUQQ2PS |
             Opcode::VMOVDDUP |
             Opcode::VPSHUFLW |
+            Opcode::VPSHUFHW |
+            Opcode::VBLENDMPD |
+            Opcode::VBLENDMPS |
+            Opcode::VPBLENDMD |
+            Opcode::VPBLENDMQ |
             Opcode::VBLENDPD |
             Opcode::VBLENDPS |
             Opcode::VBLENDVPD |
             Opcode::VBLENDVPS |
+            Opcode::VPBLENDMB |
+            Opcode::VPBLENDMW |
             Opcode::PBLENDVB |
             Opcode::PBLENDW |
             Opcode::BLENDPD |
@@ -1803,6 +2489,7 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VBROADCASTI128 |
             Opcode::VBROADCASTSD |
             Opcode::VBROADCASTSS |
+            Opcode::VPBROADCASTM |
             Opcode::VEXTRACTF128 |
             Opcode::VEXTRACTI128 |
             Opcode::VEXTRACTPS |
@@ -1811,10 +2498,49 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VGATHERDPS |
             Opcode::VGATHERQPD |
             Opcode::VGATHERQPS |
+            Opcode::VGATHERPF0DPD |
+            Opcode::VGATHERPF0DPS |
+            Opcode::VGATHERPF0QPD |
+            Opcode::VGATHERPF0QPS |
+            Opcode::VGATHERPF1DPD |
+            Opcode::VGATHERPF1DPS |
+            Opcode::VGATHERPF1QPD |
+            Opcode::VGATHERPF1QPS |
+            Opcode::VSCATTERDD |
+            Opcode::VSCATTERDQ |
+            Opcode::VSCATTERQD |
+            Opcode::VSCATTERQQ |
+            Opcode::VPSCATTERDD |
+            Opcode::VPSCATTERDQ |
+            Opcode::VPSCATTERQD |
+            Opcode::VPSCATTERQQ |
+            Opcode::VSCATTERPF0DPD |
+            Opcode::VSCATTERPF0DPS |
+            Opcode::VSCATTERPF0QPD |
+            Opcode::VSCATTERPF0QPS |
+            Opcode::VSCATTERPF1DPD |
+            Opcode::VSCATTERPF1DPS |
+            Opcode::VSCATTERPF1QPD |
+            Opcode::VSCATTERPF1QPS |
             Opcode::VINSERTF128 |
             Opcode::VINSERTI128 |
             Opcode::VINSERTPS |
             Opcode::INSERTPS |
+            Opcode::VEXTRACTF32X4 |
+            Opcode::VEXTRACTF64X2 |
+            Opcode::VEXTRACTF64X4 |
+            Opcode::VEXTRACTI32X4 |
+            Opcode::VEXTRACTI64X2 |
+            Opcode::VEXTRACTI64X4 |
+            Opcode::VINSERTF32X4 |
+            Opcode::VINSERTF64X2 |
+            Opcode::VINSERTF64X4 |
+            Opcode::VINSERTI64X2 |
+            Opcode::VINSERTI64X4 |
+            Opcode::VSHUFF32X4 |
+            Opcode::VSHUFF64X2 |
+            Opcode::VSHUFI32X4 |
+            Opcode::VSHUFI64X2 |
             Opcode::VMASKMOVDQU |
             Opcode::VMASKMOVPD |
             Opcode::VMASKMOVPS |
@@ -1845,6 +2571,32 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VMOVUPS |
             Opcode::VMOVSD |
             Opcode::VMOVSS |
+            Opcode::VMOVDQA32 |
+            Opcode::VMOVDQA64 |
+            Opcode::VMOVDQU32 |
+            Opcode::VMOVDQU64 |
+            Opcode::VPMOVM2B |
+            Opcode::VPMOVM2W |
+            Opcode::VPMOVB2M |
+            Opcode::VPMOVW2M |
+            Opcode::VPMOVSWB |
+            Opcode::VPMOVUSWB |
+            Opcode::VPMOVSQB |
+            Opcode::VPMOVUSQB |
+            Opcode::VPMOVSQW |
+            Opcode::VPMOVUSQW |
+            Opcode::VPMOVSQD |
+            Opcode::VPMOVUSQD |
+            Opcode::VPMOVSDB |
+            Opcode::VPMOVUSDB |
+            Opcode::VPMOVSDW |
+            Opcode::VPMOVUSDW |
+            Opcode::VPMOVM2D |
+            Opcode::VPMOVM2Q |
+            Opcode::VPMOVB2D |
+            Opcode::VPMOVQ2M |
+            Opcode::VMOVDQU8 |
+            Opcode::VMOVDQU16 |
 
             Opcode::VPBLENDD |
             Opcode::VPBLENDVB |
@@ -1883,6 +2635,9 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::PMOVZXDQ |
             Opcode::PMOVZXWD |
             Opcode::PMOVZXWQ |
+            Opcode::KUNPCKBW |
+            Opcode::KUNPCKWD |
+            Opcode::KUNPCKDQ |
             Opcode::VUNPCKHPD |
             Opcode::VUNPCKHPS |
             Opcode::VUNPCKLPD |
@@ -1898,9 +2653,12 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VSHUFPD |
             Opcode::VSHUFPS |
             Opcode::VPACKSSDW |
+            Opcode::VPACKUSDW |
             Opcode::PACKUSDW |
             Opcode::VPACKSSWB |
             Opcode::VPACKUSWB |
+            Opcode::VALIGND |
+            Opcode::VALIGNQ |
             Opcode::VPALIGNR |
             Opcode::PALIGNR |
             Opcode::VPERM2F128 |
@@ -1911,6 +2669,17 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPERMPD |
             Opcode::VPERMPS |
             Opcode::VPERMQ |
+            Opcode::VPERMI2D |
+            Opcode::VPERMI2Q |
+            Opcode::VPERMI2PD |
+            Opcode::VPERMI2PS |
+            Opcode::VPERMT2D |
+            Opcode::VPERMT2Q |
+            Opcode::VPERMT2PD |
+            Opcode::VPERMT2PS |
+            Opcode::VPERMI2B |
+            Opcode::VPERMI2W |
+            Opcode::VPERMW |
             Opcode::VPEXTRB |
             Opcode::VPEXTRD |
             Opcode::VPEXTRQ |
@@ -1929,11 +2698,34 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPINSRW |
             Opcode::VPMASKMOVD |
             Opcode::VPMASKMOVQ |
+            Opcode::VCOMPRESSPD |
+            Opcode::VCOMPRESSPS |
+            Opcode::VPCOMPRESSQ |
+            Opcode::VPCOMPRESSD |
+            Opcode::VEXPANDPD |
+            Opcode::VEXPANDPS |
             Opcode::VPSHUFB |
             Opcode::VPSHUFD |
             Opcode::VPHMINPOSUW |
             Opcode::PHMINPOSUW |
             Opcode::VZEROUPPER |
+            Opcode::VZEROALL |
+            Opcode::VFIXUPIMMPD |
+            Opcode::VFIXUPIMMPS |
+            Opcode::VFIXUPIMMSD |
+            Opcode::VFIXUPIMMSS |
+            Opcode::VREDUCEPD |
+            Opcode::VREDUCEPS |
+            Opcode::VREDUCESD |
+            Opcode::VREDUCESS |
+            Opcode::VGETEXPPD |
+            Opcode::VGETEXPPS |
+            Opcode::VGETEXPSD |
+            Opcode::VGETEXPSS |
+            Opcode::VGETMANTPD |
+            Opcode::VGETMANTPS |
+            Opcode::VGETMANTSD |
+            Opcode::VGETMANTSS |
             Opcode::VLDDQU |
             Opcode::BSWAP |
             Opcode::CVTDQ2PD |
@@ -2001,6 +2793,11 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::SHUFPD |
             Opcode::SHUFPS |
             Opcode::PMOVMSKB |
+            Opcode::KMOVB |
+            Opcode::KMOVW |
+            Opcode::KMOVD |
+            Opcode::KMOVQ |
+            Opcode::BNDMOV |
             Opcode::LDDQU |
             Opcode::CMC |
             Opcode::CLC |
@@ -2117,6 +2914,32 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VCOMISS |
             Opcode::VUCOMISD |
             Opcode::VUCOMISS |
+            Opcode::KORTESTB |
+            Opcode::KTESTB |
+            Opcode::KORTESTW |
+            Opcode::KTESTW |
+            Opcode::KORTESTD |
+            Opcode::KTESTD |
+            Opcode::KORTESTQ |
+            Opcode::KTESTQ |
+            Opcode::VPTESTNMD |
+            Opcode::VPTESTNMQ |
+            Opcode::VPTERNLOGD |
+            Opcode::VPTERNLOGQ |
+            Opcode::VPTESTMD |
+            Opcode::VPTESTMQ |
+            Opcode::VPTESTNMB |
+            Opcode::VPTESTNMW |
+            Opcode::VPTESTMB |
+            Opcode::VPTESTMW |
+            Opcode::VPCMPD |
+            Opcode::VPCMPUD |
+            Opcode::VPCMPQ |
+            Opcode::VPCMPUQ |
+            Opcode::VPCMPB |
+            Opcode::VPCMPUB |
+            Opcode::VPCMPW |
+            Opcode::VPCMPUW |
             Opcode::VCMPPD |
             Opcode::VCMPPS |
             Opcode::VCMPSD |
@@ -2125,6 +2948,10 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VMAXPS |
             Opcode::VMAXSD |
             Opcode::VMAXSS |
+            Opcode::VPMAXSQ |
+            Opcode::VPMAXUQ |
+            Opcode::VPMINSQ |
+            Opcode::VPMINUQ |
             Opcode::VMINPD |
             Opcode::VMINPS |
             Opcode::VMINSD |
@@ -2137,6 +2964,8 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPCMPGTD |
             Opcode::VPCMPGTQ |
             Opcode::VPCMPGTW |
+            Opcode::VPCMPESTRI |
+            Opcode::VPCMPESTRM |
             Opcode::VPCMPISTRI |
             Opcode::VPCMPISTRM |
             Opcode::VPMAXSB |
@@ -2145,9 +2974,22 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::VPMAXUB |
             Opcode::VPMAXUW |
             Opcode::VPMAXUD |
+            Opcode::VPMINSB |
             Opcode::VPMINSW |
             Opcode::VPMINSD |
+            Opcode::VPMINUB |
+            Opcode::VPMINUW |
             Opcode::VPMINUD |
+            Opcode::VFPCLASSPD |
+            Opcode::VFPCLASSPS |
+            Opcode::VFPCLASSSD |
+            Opcode::VFPCLASSSS |
+            Opcode::VRANGEPD |
+            Opcode::VRANGEPS |
+            Opcode::VRANGESD |
+            Opcode::VRANGESS |
+            Opcode::VPCONFLICTD |
+            Opcode::VPCONFLICTQ |
             Opcode::VPTEST |
             Opcode::VTESTPD |
             Opcode::VTESTPS |
@@ -2228,6 +3070,8 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::FXRSTOR |
             Opcode::LDMXCSR |
             Opcode::STMXCSR |
+            Opcode::VLDMXCSR |
+            Opcode::VSTMXCSR |
             Opcode::XSAVE |
             Opcode::XSAVEC |
             Opcode::XSAVES |
@@ -2337,7 +3181,14 @@ impl <T: fmt::Write, Y: YaxColors> Colorize<T, Y> for Opcode {
             Opcode::SENDUIPI |
             Opcode::XSUSLDTRK |
             Opcode::XRESLDTRK |
+            Opcode::BOUND |
             Opcode::ARPL |
+            Opcode::BNDMK |
+            Opcode::BNDCL |
+            Opcode::BNDCU |
+            Opcode::BNDCN |
+            Opcode::BNDLDX |
+            Opcode::BNDSTX |
             Opcode::LAR => { write!(out, "{}", colors.platform_op(self)) }
 
             Opcode::CRC32 |
@@ -2462,6 +3313,17 @@ impl Instruction {
     }
 }
 
+const MEM_SIZE_STRINGS: [&'static str; 64] = [
+    "byte", "word", "BUG", "dword", "BUG", "BUG", "BUG", "qword",
+    "far", "mword", "BUG", "BUG", "BUG", "BUG", "BUG", "xmmword",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "ymmword",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "BUG",
+    "BUG", "BUG", "BUG", "BUG", "BUG", "BUG", "ptr", "zmmword",
+];
+
 fn contextualize_intel<T: fmt::Write, Y: YaxColors>(instr: &Instruction, colors: &Y, _address: u32, _context: Option<&NoContext>, out: &mut T) -> fmt::Result {
     if instr.prefixes.lock() {
         write!(out, "lock ")?;
@@ -2469,11 +3331,8 @@ fn contextualize_intel<T: fmt::Write, Y: YaxColors>(instr: &Instruction, colors:
 
     if instr.prefixes.rep_any() {
         if [Opcode::MOVS, Opcode::CMPS, Opcode::LODS, Opcode::STOS, Opcode::INS, Opcode::OUTS].contains(&instr.opcode) {
-            // only a few of you actually use the prefix...
             if instr.prefixes.rep() {
                 write!(out, "rep ")?;
-            } else if instr.prefixes.repz() {
-                write!(out, "repz ")?;
             } else if instr.prefixes.repnz() {
                 write!(out, "repnz ")?;
             }
@@ -2489,53 +3348,19 @@ fn contextualize_intel<T: fmt::Write, Y: YaxColors>(instr: &Instruction, colors:
     if instr.operand_count > 0 {
         out.write_str(" ")?;
 
+        let x = Operand::from_spec(instr, instr.operands[0]);
+        if x.is_memory() {
+            out.write_str(MEM_SIZE_STRINGS[instr.mem_size as usize - 1])?;
+            out.write_str(" ")?;
+        }
+
         if let Some(prefix) = instr.segment_override_for_op(0) {
             write!(out, "{}:", prefix)?;
         }
-
-        let x = Operand::from_spec(instr, instr.operands[0]);
         x.colorize(colors, out)?;
 
         for i in 1..instr.operand_count {
             match instr.opcode {
-                Opcode::MOVSX_b |
-                Opcode::MOVZX_b => {
-                    match &instr.operands[i as usize] {
-                        &OperandSpec::Nothing => {
-                            return Ok(());
-                        },
-                        &OperandSpec::RegMMM => {
-                            out.write_str(", ")?;
-                        }
-                        _ => {
-                            out.write_str(", byte ")?;
-                            if let Some(prefix) = instr.segment_override_for_op(i) {
-                                write!(out, "{}:", prefix)?;
-                            }
-                        }
-                    }
-                    let x = Operand::from_spec(instr, instr.operands[i as usize]);
-                    x.colorize(colors, out)?
-                },
-                Opcode::MOVSX_w |
-                Opcode::MOVZX_w => {
-                    match &instr.operands[i as usize] {
-                        &OperandSpec::Nothing => {
-                            return Ok(());
-                        },
-                        &OperandSpec::RegMMM => {
-                            out.write_str(", ")?;
-                        }
-                        _ => {
-                            out.write_str(", word ")?;
-                            if let Some(prefix) = instr.segment_override_for_op(i) {
-                                write!(out, "{}:", prefix)?;
-                            }
-                        }
-                    }
-                    let x = Operand::from_spec(instr, instr.operands[i as usize]);
-                    x.colorize(colors, out)?
-                },
                 _ => {
                     match &instr.operands[i as usize] {
                         &OperandSpec::Nothing => {
@@ -2543,11 +3368,57 @@ fn contextualize_intel<T: fmt::Write, Y: YaxColors>(instr: &Instruction, colors:
                         },
                         _ => {
                             out.write_str(", ")?;
+                            let x = Operand::from_spec(instr, instr.operands[i as usize]);
+                            if x.is_memory() {
+                                out.write_str(MEM_SIZE_STRINGS[instr.mem_size as usize - 1])?;
+                                out.write_str(" ")?;
+                            }
                             if let Some(prefix) = instr.segment_override_for_op(i) {
                                 write!(out, "{}:", prefix)?;
                             }
-                            let x = Operand::from_spec(instr, instr.operands[i as usize]);
-                            x.colorize(colors, out)?
+                            x.colorize(colors, out)?;
+                            if let Some(evex) = instr.prefixes.evex() {
+                                if evex.broadcast() && x.is_memory() {
+                                    let scale = if instr.opcode == Opcode::VCVTPD2PS || instr.opcode == Opcode::VCVTTPD2UDQ || instr.opcode == Opcode::VCVTPD2UDQ || instr.opcode == Opcode::VCVTUDQ2PD || instr.opcode == Opcode::VCVTPS2PD || instr.opcode == Opcode::VCVTQQ2PS || instr.opcode == Opcode::VCVTDQ2PD || instr.opcode == Opcode::VCVTTPD2DQ || instr.opcode == Opcode::VFPCLASSPS || instr.opcode == Opcode::VFPCLASSPD || instr.opcode == Opcode::VCVTNEPS2BF16 || instr.opcode == Opcode::VCVTUQQ2PS || instr.opcode == Opcode::VCVTPD2DQ || instr.opcode == Opcode::VCVTTPS2UQQ || instr.opcode == Opcode::VCVTPS2UQQ || instr.opcode == Opcode::VCVTTPS2QQ || instr.opcode == Opcode::VCVTPS2QQ {
+                                        if instr.opcode == Opcode::VFPCLASSPS || instr.opcode ==  Opcode::VCVTNEPS2BF16 {
+                                            if evex.vex().l() {
+                                                8
+                                            } else if evex.lp() {
+                                                16
+                                            } else {
+                                                4
+                                            }
+                                        } else if instr.opcode == Opcode::VFPCLASSPD {
+                                            if evex.vex().l() {
+                                                4
+                                            } else if evex.lp() {
+                                                8
+                                            } else {
+                                                2
+                                            }
+                                        } else {
+                                            // vcvtpd2ps is "cool": in broadcast mode, it can read a
+                                            // double-precision float (qword), resize to single-precision,
+                                            // then broadcast that to the whole destination register. this
+                                            // means we need to show `xmm, qword [addr]{1to4}` if vector
+                                            // size is 256. likewise, scale of 8 for the same truncation
+                                            // reason if vector size is 512.
+                                            // vcvtudq2pd is the same story.
+                                            // vfpclassp{s,d} is a mystery to me.
+                                            if evex.vex().l() {
+                                                4
+                                            } else if evex.lp() {
+                                                8
+                                            } else {
+                                                2
+                                            }
+                                        }
+                                    } else {
+                                        Operand::from_spec(instr, instr.operands[i as usize - 1]).width() / instr.mem_size
+                                    };
+                                    write!(out, "{{1to{}}}", scale)?;
+                                }
+                            }
                         }
                     }
                 }
@@ -2578,8 +3449,6 @@ fn contextualize_c<T: fmt::Write, Y: YaxColors>(instr: &Instruction, _colors: &Y
             // only a few of you actually use the prefix...
             if instr.prefixes.rep() {
                 out.write_str("rep ")?;
-            } else if instr.prefixes.repz() {
-                out.write_str("repz ")?;
             } else if instr.prefixes.repnz() {
                 out.write_str("repnz ")?;
             } // TODO: other rep kinds?
@@ -2804,8 +3673,6 @@ impl <T: fmt::Write, Y: YaxColors> ShowContextual<u64, [Option<alloc::string::St
             // only a few of you actually use the prefix...
             if self.prefixes.rep() {
                 write!(out, "rep ")?;
-            } else if self.prefixes.repz() {
-                write!(out, "repz ")?;
             } else if self.prefixes.repnz() {
                 write!(out, "repnz ")?;
             }
@@ -2831,7 +3698,8 @@ impl <T: fmt::Write, Y: YaxColors> ShowContextual<u64, [Option<alloc::string::St
                 x.colorize(colors, out)?;
             }
         };
-        for i in 1..4 {
+        for i in 1..self.operand_count {
+            let i = i as usize;
             match self.opcode {
                 Opcode::MOVSX_b |
                 Opcode::MOVZX_b => {