/*
 * Test intrinsics related to integer down-converting instructions
 * like vpmovdb, where the source values are in an __m128i value.
 *
 * This test was created to check the correctness
 * of the following AVX512 intrinsics support:
 *_mm_cvtepi*
 *_mm_cvtsepi*
 *_mm_cvtusepi*
 *_mm_mask_cvtepi*
 *_mm_mask_cvtsepi*
 *_mm_mask_cvtusepi*
 *_mm_maskz_cvtepi*
 *_mm_maskz_cvtsepi*
 *_mm_maskz_cvtusepi*
 */

#include "m512_test_util.h"
#include <limits.h>

volatile int vol0 = 0;

#define soft_src_update(var) var.xmmi[vol0] = var.xmmi[vol0]

V512 i8;
V512 i16;
V512 i16_mix;
V512 i16_big;
V512 i32;
V512 i32_mix;
V512 i32_big;
V512 i64;
V512 i64_mix;

void NOINLINE init() {
  volatile int i;

  for (i = 0; i < 64; i++) {
    i8.s8[i] = i;
  }

  for (i = 0; i < 32; i++) {
    i16.s16[i] = i;
    i16_mix.s16[i] = (i & 1) ? i : -i;
    i16_big.s16[i] = 1000 * (i + 1);
    if ((i & 1) != 0) {
      i16_big.s16[i] = -i16_big.s16[i];
    }
  }

  for (i = 0; i < 16; i++) {
    i32.s32[i] = i;
    i32_mix.s32[i] = (i & 1) ? i : -i;
    i32_big.s32[i] = 1000 * (i + 1);
    if ((i & 1) != 0) {
      i32_big.s32[i] = -i32_big.s32[i];
    }
  }

  for (i = 0; i < 8; i++) {
    i64.s64[i] = i;
    i64_mix.s64[i] = (i & 1) ? i : -i;
  }
}

/* Saturation utility functions for emulation. */

static signed char NOINLINE sat16_8(short s) {
  return (s < -128) ? -128 : ((s > 127) ? 127 : s);
}

static unsigned char NOINLINE usat16_8(unsigned short s) {
  return (s > 255) ? 255 : s;
}

static signed char NOINLINE sat32_8(int s) {
  return (s < -128) ? -128 : ((s > 127) ? 127 : s);
}

static unsigned char usat32_8(unsigned int s) { return (s > 255) ? 255 : s; }

static short NOINLINE sat32_16(int s) {
  return (s < (int)0xffff8000) ? (int)0xffff8000
                               : ((s > (int)0x7fff) ? (int)0x7fff : s);
}

static unsigned short NOINLINE usat32_16(unsigned int s) {
  return (s > (unsigned int)0xffff) ? (unsigned int)0xffff : s;
}

static signed char NOINLINE sat64_8(__int64 s) {
  return (s < -128) ? -128 : ((s > 127) ? 127 : s);
}

static unsigned char NOINLINE usat64_8(unsigned __int64 s) {
  return (s > 255) ? 255 : s;
}

static short NOINLINE sat64_16(__int64 s) {
  return (s < SHRT_MIN) ? SHRT_MIN : ((s > SHRT_MAX) ? SHRT_MAX : s);
}

static unsigned short NOINLINE usat64_16(unsigned __int64 s) {
  return (s > USHRT_MAX) ? USHRT_MAX : s;
}

static int NOINLINE sat64_32(__int64 s) {
  return (s < INT_MIN) ? INT_MIN : ((s > INT_MAX) ? INT_MAX : s);
}

static unsigned int NOINLINE usat64_32(unsigned __int64 s) {
  return (s > UINT_MAX) ? UINT_MAX : s;
}

void NOINLINE do_pmovwb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xdb;

  res.xmmi[0] = _mm_cvtepi16_epi8(i16.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    expected.s8[i] = i16.s16[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi16_epi8", __LINE__);

  soft_src_update(i16);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi16_epi8(res.xmmi[1], k, i16.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i16.s16[i];
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi16_epi8", __LINE__);

  soft_src_update(i16);
  res.xmmi[0] = _mm_maskz_cvtepi16_epi8(k, i16.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i16.s16[i];
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtepi16_epi8", __LINE__);

  soft_src_update(i16);
  res.xmmi[vol0] = i16_big.xmmi[0];
  _mm_mask_cvtepi16_storeu_epi8(&res.xmmi[0], k, i16.xmmi[0]);
  expected.xmmi[0] = i16_big.xmmi[0];
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i16.s16[i];
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtepi16_storeu_epi8", __LINE__);
}

void NOINLINE do_pmovswb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xdc;

  res.xmmi[0] = _mm_cvtsepi16_epi8(i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    expected.s8[i] = sat16_8(i16_mix.s16[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi16_epi8(res.xmmi[1], k, i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat16_8(i16_mix.s16[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi16_epi8(k, i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat16_8(i16_mix.s16[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtsepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[vol0] = i16_big.xmmi[0];
  _mm_mask_cvtsepi16_storeu_epi8(&res.xmmi[0], k, i16_mix.xmmi[0]);
  expected.xmmi[0] = i16_big.xmmi[0];
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat16_8(i16_mix.s16[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtsepi16_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovuswb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xfd;

  res.xmmi[0] = _mm_cvtusepi16_epi8(i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    expected.s8[i] = usat16_8(i16_mix.u16[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi16_epi8(res.xmmi[1], k, i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat16_8(i16_mix.u16[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi16_epi8(k, i16_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat16_8(i16_mix.u16[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtusepi16_epi8", __LINE__);

  soft_src_update(i16_mix);
  res.xmmi[vol0] = i16_big.xmmi[0];
  _mm_mask_cvtusepi16_storeu_epi8(&res.xmmi[0], k, i16_mix.xmmi[0]);
  expected.xmmi[0] = i16_big.xmmi[0];
  for (i = 0; i < 8; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat16_8(i16_mix.u16[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtusepi16_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovdb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xab;

  res.xmmi[0] = _mm_cvtepi32_epi8(i32.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    expected.s8[i] = i32.s32[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi32_epi8", __LINE__);

  soft_src_update(i32);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi32_epi8(res.xmmi[1], k, i32.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i32.s32[i];
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi32_epi8", __LINE__);

  soft_src_update(i32);
  res.xmmi[0] = _mm_maskz_cvtepi32_epi8(k, i32.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i32.s32[i];
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtepi32_epi8", __LINE__);

  soft_src_update(i32);
  res.xmmi[vol0] = i32_big.xmmi[0];
  _mm_mask_cvtepi32_storeu_epi8(&res.xmmi[0], k, i32.xmmi[0]);
  expected.xmmi[0] = i32_big.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i32.s32[i];
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtepi32_storeu_epi8", __LINE__);
}

void NOINLINE do_pmovsdb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xdb;

  res.xmmi[0] = _mm_cvtsepi32_epi8(i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    expected.s8[i] = sat32_8(i32_mix.s32[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi32_epi8(res.xmmi[1], k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat32_8(i32_mix.s32[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi32_epi8(k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat32_8(i32_mix.s32[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtsepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[vol0] = i32_big.xmmi[0];
  _mm_mask_cvtsepi32_storeu_epi8(&res.xmmi[0], k, i32_mix.xmmi[0]);
  expected.xmmi[0] = i32_big.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat32_8(i32_mix.s32[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtsepi32_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovusdb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xfd;

  res.xmmi[0] = _mm_cvtusepi32_epi8(i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    expected.s8[i] = usat32_8(i32_mix.u32[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi32_epi8(res.xmmi[1], k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat32_8(i32_mix.u32[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi32_epi8(k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat32_8(i32_mix.u32[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtusepi32_epi8", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[vol0] = i32_big.xmmi[0];
  _mm_mask_cvtusepi32_storeu_epi8(&res.xmmi[0], k, i32_mix.xmmi[0]);
  expected.xmmi[0] = i32_big.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat32_8(i32_mix.u32[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtusepi32_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovdw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xcd;

  res.xmmi[0] = _mm_cvtepi32_epi16(i32.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    expected.s16[i] = i32.s32[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi32_epi16", __LINE__);

  soft_src_update(i32);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i8.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi32_epi16(res.xmmi[1], k, i32.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i32.s32[i];
    } else {
      expected.s16[i] = res.s16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi32_epi16", __LINE__);

  soft_src_update(i32);
  res.xmmi[0] = _mm_maskz_cvtepi32_epi16(k, i32.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i32.s32[i];
    } else {
      expected.s16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtepi32_epi16", __LINE__);

  soft_src_update(i32);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtepi32_storeu_epi16(&res.xmmi[0], k, i32.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i32.s32[i];
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtepi32_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovsdw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xfe;

  res.xmmi[0] = _mm_cvtsepi32_epi16(i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    expected.s16[i] = sat32_16(i32_mix.s32[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi32_epi16(res.xmmi[1], k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat32_16(i32_mix.s32[i]);
    } else {
      expected.s16[i] = res.s16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi32_epi16(k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat32_16(i32_mix.s32[i]);
    } else {
      expected.s16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtsepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtsepi32_storeu_epi16(&res.xmmi[0], k, i32_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat32_16(i32_mix.s32[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtsepi32_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovusdw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xfe;

  res.xmmi[0] = _mm_cvtusepi32_epi16(i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    expected.u16[i] = usat32_16(i32_mix.u32[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi32_epi16(res.xmmi[1], k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.u16[i] = usat32_16(i32_mix.u32[i]);
    } else {
      expected.u16[i] = res.u16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi32_epi16(k, i32_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.u16[i] = usat32_16(i32_mix.u32[i]);
    } else {
      expected.u16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtusepi32_epi16", __LINE__);

  soft_src_update(i32_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtusepi32_storeu_epi16(&res.xmmi[0], k, i32_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 4; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = usat32_16(i32_mix.s32[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtusepi32_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovqb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0x76;

  res.xmmi[0] = _mm_cvtepi64_epi8(i64.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.s8[i] = i64.s64[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi64_epi8", __LINE__);

  /*
   * Exercise ciscization.
   */

  _mm_store_sd(&res.f64[2], _mm_castsi128_pd(_mm_cvtepi64_epi8(i64.xmmi[0])));
  check_equal_nd(&res.f64[2], &expected, 2, "_mm_cvtepi64_epi8 ciscized",
                 __LINE__);

  soft_src_update(i64);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi64_epi8(res.xmmi[1], k, i64.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i64.s64[i];
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi64_epi8", __LINE__);

  soft_src_update(i64);
  res.xmmi[0] = _mm_maskz_cvtepi64_epi8(k, i64.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i64.s64[i];
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtepi64_epi8", __LINE__);

  soft_src_update(i64);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtepi64_storeu_epi8(&res.xmmi[0], k, i64.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = i64.s64[i];
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtepi64_storeu_epi8", __LINE__);
}

void NOINLINE do_pmovsqb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0x67;

  res.xmmi[0] = _mm_cvtsepi64_epi8(i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.s8[i] = sat64_8(i64_mix.s64[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi64_epi8(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat64_8(i64_mix.s64[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi64_epi8(k, i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat64_8(i64_mix.s64[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtsepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtsepi64_storeu_epi8(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = sat64_8(i64_mix.s64[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtsepi64_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovusqb() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0x67;

  res.xmmi[0] = _mm_cvtusepi64_epi8(i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.u8[i] = (i64_mix.u64[i] > 255) ? 255 : i64_mix.u64[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i16.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi64_epi8(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat64_8(i64_mix.u64[i]);
    } else {
      expected.s8[i] = res.s8[16 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi64_epi8(k, i64_mix.xmmi[0]);

  expected.u64[0] = 0;
  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat64_8(i64_mix.u64[i]);
    } else {
      expected.s8[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtusepi64_epi8", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtusepi64_storeu_epi8(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s8[i] = usat64_8(i64_mix.u64[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtusepi64_storeu_epi8",
                 __LINE__);
}

void NOINLINE do_pmovqw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xe9;

  res.xmmi[0] = _mm_cvtepi64_epi16(i64.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    expected.s16[i] = i64.s64[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi64_epi16", __LINE__);

  soft_src_update(i64);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi64_epi16(res.xmmi[1], k, i64.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i64.s64[i];
    } else {
      expected.s16[i] = res.s16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi64_epi16", __LINE__);

  soft_src_update(i64);
  res.xmmi[0] = _mm_maskz_cvtepi64_epi16(k, i64.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i64.s64[i];
    } else {
      expected.s16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi64_epi16", __LINE__);

  soft_src_update(i64);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtepi64_storeu_epi16(&res.xmmi[0], k, i64.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = i64.s64[i];
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtepi64_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovsqw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xe9;

  res.xmmi[0] = _mm_cvtsepi64_epi16(i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    expected.s16[i] = sat64_16(i64_mix.s64[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi64_epi16(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat64_16(i64_mix.s64[i]);
    } else {
      expected.s16[i] = res.s16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi64_epi16(k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat64_16(i64_mix.s64[i]);
    } else {
      expected.s16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtsepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtsepi64_storeu_epi16(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = sat64_16(i64_mix.s64[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtsepi64_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovusqw() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xe9;
  unsigned __int64 r;

  res.xmmi[0] = _mm_cvtusepi64_epi16(i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    expected.s16[i] = usat64_16(i64_mix.u64[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i16.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi64_epi16(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = usat64_16(i64_mix.u64[i]);
    } else {
      expected.s16[i] = res.s16[8 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi64_epi16(k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  expected.u64[0] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = usat64_16(i64_mix.u64[i]);
    } else {
      expected.s16[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi64_epi16", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtusepi64_storeu_epi16(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s16[i] = usat64_16(i64_mix.u64[i]);
    }
  }

  check_equal_nd(&res, &expected, 1, "_mm_mask_cvtusepi64_storeu_epi16",
                 __LINE__);
}

void NOINLINE do_pmovqd() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xcf;

  res.xmmi[0] = _mm_cvtepi64_epi32(i64.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.s32[i] = i64.s64[i];
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtepi64_epi32", __LINE__);

  soft_src_update(i64);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i8.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtepi64_epi32(res.xmmi[1], k, i64.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = i64.s64[i];
    } else {
      expected.s32[i] = res.s32[4 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi64_epi32", __LINE__);

  soft_src_update(i64);
  res.xmmi[0] = _mm_maskz_cvtepi64_epi32(k, i64.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = i64.s64[i];
    } else {
      expected.s32[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtepi64_epi32", __LINE__);

  soft_src_update(i64);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtepi64_storeu_epi32(&res.xmmi[0], k, i64.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = i64.s64[i];
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtepi64_storeu_epi32",
                 __LINE__);
}

void NOINLINE do_pmovsqd() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xcf;

  res.xmmi[0] = _mm_cvtsepi64_epi32(i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.s32[i] = sat64_32(i64_mix.s64[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtsepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i8.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtsepi64_epi32(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = sat64_32(i64_mix.s64[i]);
    } else {
      expected.s32[i] = res.s32[4 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtsepi64_epi32(k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = sat64_32(i64_mix.s64[i]);
    } else {
      expected.s32[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtsepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtsepi64_storeu_epi32(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = sat64_32(i64_mix.s64[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtsepi64_storeu_epi32",
                 __LINE__);
}

void NOINLINE do_pmovusqd() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k = 0xcf;

  res.xmmi[0] = _mm_cvtusepi64_epi32(i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    expected.u32[i] = usat64_32(i64_mix.u64[i]);
  }

  check_equal_nd(&res, &expected, 4, "_mm_cvtusepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[1] = i8.xmmi[0];
  res.xmmi[0] = i8.xmmi[1];
  res.xmmi[0] = _mm_mask_cvtusepi64_epi32(res.xmmi[1], k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.u32[i] = usat64_32(i64_mix.u64[i]);
    } else {
      expected.s32[i] = res.s32[4 + i]; // From res.xmmi[1].
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_mask_cvtusepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[0] = _mm_maskz_cvtusepi64_epi32(k, i64_mix.xmmi[0]);

  expected.u64[1] = 0;
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.u32[i] = usat64_32(i64_mix.u64[i]);
    } else {
      expected.s32[i] = 0;
    }
  }

  check_equal_nd(&res, &expected, 4, "_mm_maskz_cvtusepi64_epi32", __LINE__);

  soft_src_update(i64_mix);
  res.xmmi[vol0] = i8.xmmi[0];
  _mm_mask_cvtusepi64_storeu_epi32(&res.xmmi[0], k, i64_mix.xmmi[0]);
  expected.xmmi[0] = i8.xmmi[0];
  for (i = 0; i < 2; i++) {
    if ((1 << i) & k) {
      expected.s32[i] = usat64_32(i64_mix.u64[i]);
    }
  }

  check_equal_nd(&res, &expected, 2, "_mm_mask_cvtusepi64_storeu_epi32",
                 __LINE__);
}

int main(int argc, char *argv[]) {
  init();

  do_pmovwb();
  do_pmovswb();
  do_pmovuswb();

  do_pmovdb();
  do_pmovsdb();
  do_pmovusdb();

  do_pmovdw();
  do_pmovsdw();
  do_pmovusdw();

  do_pmovqb();
  do_pmovsqb();
  do_pmovusqb();

  do_pmovqw();
  do_pmovsqw();
  do_pmovusqw();

  do_pmovqd();
  do_pmovsqd();
  do_pmovusqd();

  if (n_errs != 0) {
    printf("FAILED\n");
    return 1;
  }

  printf("PASSED\n");
  return 0;
}