/*
 * Test pertumes and shuffle intrinsics.
 * This test was created to check the correctness
 * of the following intrinsics support:
 * _mm*_permute*_pd()
 * _mm*_shuffle_epi8()
 */

#include "m512_test_util.h"

volatile int vol0 = 0;

V512 i8;
V512 i8_mix;
V512 i8_big;
V512 i16;
V512 i16_mix;
V512 i16_big;
V512 i32;
V512 i32_mix;
V512 i32_big;
V512 i64;
V512 i64_mix;
V512 i64_big;

void NOINLINE init() {
  volatile int i;

  for (i = 0; i < 64; i++) {
    i8.s8[i] = i;
    i8_mix.s8[i] = (i & 1) ? i : -i;
    i8_big.s8[i] = 1000 * (i + 1);
  }

  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;
    i64_big.s64[i] = 1000 * (i + 1);
    if ((i & 1) != 0) {
      i64_big.s64[i] = -i64_big.s64[i];
    }
  }
}

#define CHECK_PSHUFB(n_elems, dest, mask, zeroing, name)                       \
  {                                                                            \
    int i, lane;                                                               \
    for (i = 0; i < n_elems; i++) {                                            \
      expected.s8[i] = 0;                                                      \
      if (i8_mix.s8[i] >= 0) {                                                 \
        lane = i / 16;                                                         \
        expected.s8[i] = i8.s8[16 * lane + (i8_mix.s8[i] & 0xf)];              \
      }                                                                        \
      if ((mask & (1LL << i)) == 0) {                                          \
        if (zeroing) {                                                         \
          expected.s8[i] = 0;                                                  \
        } else {                                                               \
          expected.s8[i] = dest.s8[i];                                         \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems / 4, name, __LINE__);              \
    i8_mix.xmmi[vol0] = i8_mix.xmmi[vol0];                                     \
  }

void NOINLINE do_pshufb() {
  V512 res;
  V512 expected;
  __mmask64 k64 = 0xFFFFFFFFFFFFFFFFLL;

  /* Non-masked versions. */
  res.xmmi[vol0] = _mm_shuffle_epi8(i8.xmmi[vol0], i8_mix.xmmi[vol0]);
  CHECK_PSHUFB(16, i8_big, k64, 0, "_mm_shuffle_epi8");

  res.ymmi[vol0] = _mm256_shuffle_epi8(i8.ymmi[vol0], i8_mix.ymmi[vol0]);
  CHECK_PSHUFB(32, i8_big, k64, 0, "_mm256_shuffle_epi8");

  res.zmmi = _mm512_shuffle_epi8(i8.zmmi, i8_mix.zmmi);
  CHECK_PSHUFB(64, i8_big, k64, 0, "_mm512_shuffle_epi8");

  /* Masked versions. */
  k64 = 0xA4A4A4A4A4A4A4A4LL;
  res.xmmi[vol0] = _mm_mask_shuffle_epi8(i8_big.xmmi[vol0], k64, i8.xmmi[vol0],
                                         i8_mix.xmmi[vol0]);
  CHECK_PSHUFB(16, i8_big, k64, 0, "_mm_mask_shuffle_epi8");

  res.ymmi[vol0] = _mm256_mask_shuffle_epi8(i8_big.ymmi[vol0], k64,
                                            i8.ymmi[vol0], i8_mix.ymmi[vol0]);
  CHECK_PSHUFB(32, i8_big, k64, 0, "_mm256_mask_shuffle_epi8");

  res.zmmi = _mm512_mask_shuffle_epi8(i8_big.zmmi, k64, i8.zmmi, i8_mix.zmmi);
  CHECK_PSHUFB(64, i8_big, k64, 0, "_mm512_mask_shuffle_epi8");

  /* Zero-masked versions. */
  k64 = 0x4A4A4A4A4A4A4A4ALL;
  res.xmmi[vol0] =
      _mm_maskz_shuffle_epi8(k64, i8.xmmi[vol0], i8_mix.xmmi[vol0]);
  CHECK_PSHUFB(16, i8_big, k64, 1, "_mm_maskz_shuffle_epi8");

  res.ymmi[vol0] =
      _mm256_maskz_shuffle_epi8(k64, i8.ymmi[vol0], i8_mix.ymmi[vol0]);
  CHECK_PSHUFB(32, i8_big, k64, 1, "_mm256_maskz_shuffle_epi8");

  res.zmmi = _mm512_maskz_shuffle_epi8(k64, i8.zmmi, i8_mix.zmmi);
  CHECK_PSHUFB(64, i8_big, k64, 1, "_mm512_maskz_shuffle_epi8");
}

void NOINLINE do_perm_epi32() {
  __mmask16 k;

  volatile __m512i v1 =
      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
  volatile __m512i v2 =
      _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
  __m512i z1 = v1;
  __m512i z2 = v2;
  __m512i z3;
  __m512i e1;
  volatile __m256i y1 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
  volatile __m256i y2 = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
  __m256i y3;
  __m256i e2;

  z3 = _mm512_permutexvar_epi32(z2, z1);
  check_equal_nd(&z3, &z2, 16, "_mm512_permutexvar_epi32", __LINE__);

  k = 0xa97e;

  y3 = y1;
  y3 = _mm256_mask_permutexvar_epi32(y3, k, y2, y1);
  e2 = _mm256_set_epi32(7, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&y3, &e2, 8, "_mm256_mask_permutexvar_epi32", __LINE__);

  z3 = v1;
  z3 = _mm512_mask_permutexvar_epi32(z3, k, z2, z1);
  e1 = _mm512_set_epi32(0, 14, 2, 12, 4, 10, 9, 7, 7, 9, 10, 11, 12, 13, 14, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_mask_permutexvar_epi32", __LINE__);

  y3 = _mm256_maskz_permutexvar_epi32(k, y2, y1);
  e2 = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&y3, &e2, 8, "_mm256_maskz_permutexvar_epi32", __LINE__);

  z3 = _mm512_maskz_permutexvar_epi32(k, z2, z1);
  e1 = _mm512_set_epi32(0, 0, 2, 0, 4, 0, 0, 7, 0, 9, 10, 11, 12, 13, 14, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_maskz_permutexvar_epi32", __LINE__);
}

void NOINLINE do_perm_ps() {
  __mmask16 k;

  volatile __m512i v1 =
      _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
  volatile __m512i v2 =
      _mm512_set_epi32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
  __m512 z1 = _mm512_castsi512_ps(v1);
  __m512i z2 = v2;
  __m512 z3;
  __m512i e1;
  volatile __m256 y1 =
      _mm256_castsi256_ps(_mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0));
  volatile __m256i y2 = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
  __m256 y3, e2;

  y3 = _mm256_permutevar8x32_ps(y1, y2);
  e2 = _mm256_castsi256_ps(y2);
  check_equal_nd(&y3, &e2, 8, "_mm256_permutevar8x32_ps", __LINE__);

  y3 = _mm256_permutexvar_ps(y2, y1);
  e2 = _mm256_castsi256_ps(y2);
  check_equal_nd(&y3, &e2, 8, "_mm256_permutexvar_ps", __LINE__);

  z3 = _mm512_permutexvar_ps(z2, z1);
  check_equal_nd(&z3, &z2, 16, "_mm512_permutexvar_ps", __LINE__);

  k = 0xa97e;
  y3 = y1;
  y3 = _mm256_mask_permutexvar_ps(y3, k, y2, y1);
  e2 = _mm256_castsi256_ps(_mm256_set_epi32(7, 1, 2, 3, 4, 5, 6, 0));
  check_equal_nd(&y3, &e2, 8, "_mm256_mask_permutexvar_ps", __LINE__);

  k = 0xa97e;
  z3 = _mm512_castsi512_ps(v1);
  z3 = _mm512_mask_permutexvar_ps(z3, k, z2, z1);
  e1 = _mm512_set_epi32(0, 14, 2, 12, 4, 10, 9, 7, 7, 9, 10, 11, 12, 13, 14, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_mask_permutexvar_ps", __LINE__);

  k = 0xa97e;
  y3 = y1;
  y3 = _mm256_maskz_permutexvar_ps(k, y2, y1);
  e2 = _mm256_castsi256_ps(_mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 0));
  check_equal_nd(&y3, &e2, 8, "_mm256_maskz_permutexvar_ps", __LINE__);

  k = 0xa97e;
  z3 = _mm512_castsi512_ps(v1);
  z3 = _mm512_maskz_permutexvar_ps(k, z2, z1);
  e1 = _mm512_set_epi32(0, 0, 2, 0, 4, 0, 0, 7, 0, 9, 10, 11, 12, 13, 14, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_maskz_permutexvar_ps", __LINE__);
}

#define CHECK_PERMI_PS(n_elems, dest, mask, zeroing, name)                     \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; ++i) {                                            \
      expected.f32[i] = i32.f32[4 * (i / 4) + (i32_mix.s32[i] & 0x3)];         \
      if ((mask & (1LL << i)) == 0) {                                          \
        if (zeroing) {                                                         \
          expected.f32[i] = 0;                                                 \
        } else {                                                               \
          expected.f32[i] = dest.f32[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems, name, __LINE__);                  \
    i32_mix.ymmi[vol0] = i32_mix.ymmi[vol0];                                   \
  }

#define CHECK_PERMI_PS_IMM(n_elems, dest, mask, zeroing, name)                 \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; ++i) {                                            \
      expected.f32[i] = i32.f32[4 * (i / 4) + ((imm >> ((i % 4) * 2)) & 0x3)]; \
      if ((mask & (1LL << i)) == 0) {                                          \
        if (zeroing) {                                                         \
          expected.f32[i] = 0;                                                 \
        } else {                                                               \
          expected.f32[i] = dest.f32[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems, name, __LINE__);                  \
    i32.ymmi[vol0] = i32.ymmi[vol0];                                           \
  }

void NOINLINE do_permi_ps() {
  V512 res;
  V512 expected;
  __mmask16 k = 0xFFFF;
  char imm;

  res.xmm[vol0] = _mm_permutevar_ps(i32.xmm[vol0], i32_mix.xmmi[vol0]);
  CHECK_PERMI_PS(2, i32_big, k, 0, "_mm_permutevar_ps");
  res.ymm[vol0] = _mm256_permutevar_ps(i32.ymm[vol0], i32_mix.ymmi[vol0]);
  CHECK_PERMI_PS(4, i32_big, k, 0, "_mm256_permutevar_ps");
  res.zmm = _mm512_permutevar_ps(i32.zmm, i32_mix.zmmi);
  CHECK_PERMI_PS(8, i32_big, k, 0, "_mm512_permutevar_ps");

  k = 0xA4;
  res.xmm[vol0] = _mm_mask_permutevar_ps(i32_big.xmm[vol0], k, i32.xmm[vol0],
                                         i32_mix.xmmi[vol0]);
  CHECK_PERMI_PS(2, i32_big, k, 0, "_mm_mask_permutevar_ps");
  res.ymm[vol0] = _mm256_mask_permutevar_ps(i32_big.ymm[vol0], k, i32.ymm[vol0],
                                            i32_mix.ymmi[vol0]);
  CHECK_PERMI_PS(4, i32_big, k, 0, "_mm256_mask_permutevar_ps");
  res.zmm = _mm512_mask_permutevar_ps(i32_big.zmm, k, i32.zmm, i32_mix.zmmi);
  CHECK_PERMI_PS(8, i32_big, k, 0, "_mm512_mask_permutevar_ps");

  k = 0xA4;
  res.xmm[vol0] = _mm_maskz_permutevar_ps(k, i32.xmm[vol0], i32_mix.xmmi[vol0]);
  CHECK_PERMI_PS(2, i32_big, k, 1, "_mm_maskz_permutevar_ps");
  res.ymm[vol0] =
      _mm256_maskz_permutevar_ps(k, i32.ymm[vol0], i32_mix.ymmi[vol0]);
  CHECK_PERMI_PS(4, i32_big, k, 1, "_mm256_maskz_permutevar_ps");
  res.zmm = _mm512_maskz_permutevar_ps(k, i32.zmm, i32_mix.zmmi);
  CHECK_PERMI_PS(8, i32_big, k, 1, "_mm512_maskz_permutevar_ps");

  imm = 0xA4;
  k = 0xFF;
  res.xmm[vol0] = _mm_permute_ps(i32.xmm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(2, i32_big, k, 0, "_mm_permute_ps");
  res.ymm[vol0] = _mm256_permute_ps(i32.ymm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(4, i32_big, k, 0, "_mm256_permute_ps");
  res.zmm = _mm512_permute_ps(i32.zmm, 0xA4);
  CHECK_PERMI_PS_IMM(8, i32_big, k, 0, "_mm512_permute_pd");

  k = 0xA4;
  res.xmm[vol0] =
      _mm_mask_permute_ps(i32_big.xmm[vol0], k, i32.xmm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(2, i32_big, k, 0, "_mm_mask_permute_ps");
  res.ymm[vol0] =
      _mm256_mask_permute_ps(i32_big.ymm[vol0], k, i32.ymm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(4, i32_big, k, 0, "_mm256_mask_permute_ps");
  res.zmm = _mm512_mask_permute_ps(i32_big.zmm, k, i32.zmm, 0xA4);
  CHECK_PERMI_PS_IMM(8, i32_big, k, 0, "_mm512_mask_permute_ps");

  k = 0xA4;
  res.xmm[vol0] = _mm_maskz_permute_ps(k, i32.xmm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(2, i32_big, k, 1, "_mm_maskz_permute_ps");
  res.ymm[vol0] = _mm256_maskz_permute_ps(k, i32.ymm[vol0], 0xA4);
  CHECK_PERMI_PS_IMM(4, i32_big, k, 1, "_mm256_maskz_permute_ps");
  res.zmm = _mm512_maskz_permute_ps(k, i32.zmm, 0xA4);
  CHECK_PERMI_PS_IMM(8, i32_big, k, 1, "_mm512_maskz_permute_ps");
}

void NOINLINE do_perm_epi64() {
  __mmask8 k;

  volatile __m512i v1 = _mm512_set_epi64(7, 6, 5, 4, 3, 2, 1, 0);
  volatile __m512i v2 = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
  __m512i z1 = v1;
  __m512i z2 = v2;
  __m512i z3;
  __m512i e1;
  volatile __m256i y1 = _mm256_set_epi64x(3, 2, 1, 0);
  volatile __m256i y2 = _mm256_set_epi64x(0, 1, 2, 3);
  __m256i y3, e2;

  y3 = _mm256_permutexvar_epi64(y2, y1);
  e2 = y2;
  check_equal_nd(&y3, &e2, 8, "_mm256_permutexvar_epi64", __LINE__);

  z3 = _mm512_permutexvar_epi64(z2, z1);
  check_equal_nd(&z3, &z2, 16, "_mm512_permutexvar_epi64", __LINE__);

  k = 0x7e;
  y3 = y1;
  y3 = _mm256_mask_permutexvar_epi64(y3, k, y2, y1);
  e2 = _mm256_set_epi64x(0, 1, 2, 0);
  check_equal_nd(&y3, &e2, 8, "_mm256_mask_permutexvar_epi64", __LINE__);

  k = 0x7e;
  z3 = v1;
  z3 = _mm512_mask_permutexvar_epi64(z3, k, z2, z1);
  e1 = _mm512_set_epi64(7, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_mask_permutexvar_epi64", __LINE__);

  k = 0x7c;
  y3 = y1;
  y3 = _mm256_maskz_permutexvar_epi64(k, y2, y1);
  e2 = _mm256_set_epi64x(0, 1, 0, 0);
  check_equal_nd(&y3, &e2, 8, "_mm256_maskz_permutexvar_epi64", __LINE__);

  k = 0x7e;
  z3 = v1;
  z3 = _mm512_maskz_permutexvar_epi64(k, z2, z1);
  e1 = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_maskz_permutexvar_epi64", __LINE__);
}

void NOINLINE do_perm_pd() {
  __mmask8 k;

  volatile __m512i v1 = _mm512_set_epi64(7, 6, 5, 4, 3, 2, 1, 0);
  volatile __m512i v2 = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 7);
  __m512d z1 = _mm512_castsi512_pd(v1);
  __m512i z2 = v2;
  __m512d z3;
  __m512i e1;
  volatile __m256i yv1;
  volatile __m256i yv2;
  __m256d y1;
  __m256i y2;
  __m256d y3;
  __m256i ye1;

  z3 = _mm512_permutexvar_pd(z2, z1);
  check_equal_nd(&z3, &z2, 16, "_mm512_permutexvar_pd", __LINE__);

  k = 0x7e;
  z3 = _mm512_castsi512_pd(v1);
  z3 = _mm512_mask_permutexvar_pd(z3, k, z2, z1);
  e1 = _mm512_set_epi64(7, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_mask_permutexvar_pd", __LINE__);

  z3 = _mm512_maskz_permutexvar_pd(k, z2, z1);
  e1 = _mm512_set_epi64(0, 1, 2, 3, 4, 5, 6, 0);
  check_equal_nd(&z3, &e1, 16, "_mm512_maskz_permutexvar_pd", __LINE__);

  /* 256 */
  yv1 = _mm256_set_epi64x(7, 6, 5, 4);
  yv2 = _mm256_set_epi64x(4, 5, 6, 7);
  y1 = _mm256_castsi256_pd(yv1);
  y2 = yv2;

  y3 = _mm256_permutexvar_pd(y2, y1);
  check_equal_nd(&y3, &y2, 8, "_mm256_permutexvar_pd", __LINE__);

  k = 0x6;
  y3 = _mm256_castsi256_pd(yv1);
  y3 = _mm256_mask_permutexvar_pd(y3, k, y2, y1);
  ye1 = _mm256_set_epi64x(7, 5, 6, 4);
  check_equal_nd(&y3, &ye1, 8, "_mm256_mask_permutexvar_pd", __LINE__);

  y3 = _mm256_maskz_permutexvar_pd(k, y2, y1);
  ye1 = _mm256_set_epi64x(0, 5, 6, 0);
  check_equal_nd(&y3, &ye1, 8, "_mm256_maskz_permutexvar_pd", __LINE__);
}

#define CHECK_PERMI_PD(n_elems, dest, mask, zeroing, name)                     \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; ++i) {                                            \
      if ((i64_mix.s64[i] & 0x2) == 0) {                                       \
        expected.f64[i] = i64.f64[2 * (i / 2)];                                \
      } else {                                                                 \
        expected.f64[i] = i64.f64[2 * (i / 2) + 1];                            \
      }                                                                        \
      if ((mask & (1LL << i)) == 0) {                                          \
        if (zeroing) {                                                         \
          expected.f64[i] = 0;                                                 \
        } else {                                                               \
          expected.f64[i] = dest.f64[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems * 2, name, __LINE__);              \
    i64_mix.ymmi[vol0] = i64_mix.ymmi[vol0];                                   \
  }

#define CHECK_PERMI_PD_IMM(n_elems, dest, mask, zeroing, name)                 \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; ++i) {                                            \
      if (((imm >> i) & 0x1) == 0) {                                           \
        expected.f64[i] = i64.f64[2 * (i / 2)];                                \
      } else {                                                                 \
        expected.f64[i] = i64.f64[2 * (i / 2) + 1];                            \
      }                                                                        \
      if ((mask & (1LL << i)) == 0) {                                          \
        if (zeroing) {                                                         \
          expected.f64[i] = 0;                                                 \
        } else {                                                               \
          expected.f64[i] = dest.f64[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems * 2, name, __LINE__);              \
    i64.ymmi[vol0] = i64.ymmi[vol0];                                           \
  }

void NOINLINE do_permi_pd() {
  V512 res;
  V512 expected;
  __mmask8 k = 0xFF;
  char imm;

  res.xmmd[vol0] = _mm_permutevar_pd(i64.xmmd[vol0], i64_mix.xmmi[vol0]);
  CHECK_PERMI_PD(2, i64_big, k, 0, "_mm_permutevar_pd");
  res.ymmd[vol0] = _mm256_permutevar_pd(i64.ymmd[vol0], i64_mix.ymmi[vol0]);
  CHECK_PERMI_PD(4, i64_big, k, 0, "_mm256_permutevar_pd");
  res.zmmd = _mm512_permutevar_pd(i64.zmmd, i64_mix.zmmi);
  CHECK_PERMI_PD(8, i64_big, k, 0, "_mm512_permutevar_pd");

  k = 0xA4;
  res.xmmd[vol0] = _mm_mask_permutevar_pd(i64_big.xmmd[vol0], k, i64.xmmd[vol0],
                                          i64_mix.xmmi[vol0]);
  CHECK_PERMI_PD(2, i64_big, k, 0, "_mm_mask_permutevar_pd");
  res.ymmd[vol0] = _mm256_mask_permutevar_pd(
      i64_big.ymmd[vol0], k, i64.ymmd[vol0], i64_mix.ymmi[vol0]);
  CHECK_PERMI_PD(4, i64_big, k, 0, "_mm256_mask_permutevar_pd");
  res.zmmd = _mm512_mask_permutevar_pd(i64_big.zmmd, k, i64.zmmd, i64_mix.zmmi);
  CHECK_PERMI_PD(8, i64_big, k, 0, "_mm512_mask_permutevar_pd");

  k = 0xA4;
  res.xmmd[vol0] =
      _mm_maskz_permutevar_pd(k, i64.xmmd[vol0], i64_mix.xmmi[vol0]);
  CHECK_PERMI_PD(2, i64_big, k, 1, "_mm_maskz_permutevar_pd");
  res.ymmd[vol0] =
      _mm256_maskz_permutevar_pd(k, i64.ymmd[vol0], i64_mix.ymmi[vol0]);
  CHECK_PERMI_PD(4, i64_big, k, 1, "_mm256_maskz_permutevar_pd");
  res.zmmd = _mm512_maskz_permutevar_pd(k, i64.zmmd, i64_mix.zmmi);
  CHECK_PERMI_PD(8, i64_big, k, 1, "_mm512_maskz_permutevar_pd");

  imm = 0xA4;
  k = 0xFF;
  res.xmmd[vol0] = _mm_permute_pd(i64.xmmd[vol0], 0xA4 & 0x3);
  CHECK_PERMI_PD_IMM(2, i64_big, k, 0, "_mm_permute_pd");
  res.ymmd[vol0] = _mm256_permute_pd(i64.ymmd[vol0], 0xA4 & 0xf);
  CHECK_PERMI_PD_IMM(4, i64_big, k, 0, "_mm256_permute_pd");
  res.zmmd = _mm512_permute_pd(i64.zmmd, 0xA4);
  CHECK_PERMI_PD_IMM(8, i64_big, k, 0, "_mm512_permute_pd");

  k = 0xA4;
  res.xmmd[vol0] =
      _mm_mask_permute_pd(i64_big.xmmd[vol0], k, i64.xmmd[vol0], 0xA4 & 0x3);
  CHECK_PERMI_PD_IMM(2, i64_big, k, 0, "_mm_mask_permute_pd");
  res.ymmd[vol0] =
      _mm256_mask_permute_pd(i64_big.ymmd[vol0], k, i64.ymmd[vol0], 0xA4 & 0xf);
  CHECK_PERMI_PD_IMM(4, i64_big, k, 0, "_mm256_mask_permute_pd");
  res.zmmd = _mm512_mask_permute_pd(i64_big.zmmd, k, i64.zmmd, 0xA4);
  CHECK_PERMI_PD_IMM(8, i64_big, k, 0, "_mm512_mask_permute_pd");

  k = 0xA4;
  res.xmmd[vol0] = _mm_maskz_permute_pd(k, i64.xmmd[vol0], 0xA4 & 0x3);
  CHECK_PERMI_PD_IMM(2, i64_big, k, 1, "_mm_maskz_permute_pd");
  res.ymmd[vol0] = _mm256_maskz_permute_pd(k, i64.ymmd[vol0], 0xA4 & 0xf);
  CHECK_PERMI_PD_IMM(4, i64_big, k, 1, "_mm256_maskz_permute_pd");
  res.zmmd = _mm512_maskz_permute_pd(k, i64.zmmd, 0xA4);
  CHECK_PERMI_PD_IMM(8, i64_big, k, 1, "_mm512_maskz_permute_pd");
}

void NOINLINE do_perm_epi64_imm() {
  __mmask8 k;

  volatile __m512i v1 = _mm512_set_epi64(7, 6, 5, 4, 3, 2, 1, 0);
  __m512i z1 = v1;
  __m512i z2;
  __m512i e1;
  volatile __m256i y1 = _mm256_set_epi64x(3, 2, 1, 0);
  __m256i y2, e2;

  y2 = y1;
  y2 = _mm256_permutex_epi64(y2, 0x7a);
  e2 = _mm256_set_epi64x(1, 3, 2, 2);
  check_equal_nd(&y2, &e2, 8, "_mm256_permutex_epi64", __LINE__);

  z2 = _mm512_permutex_epi64(z1, 0x7a);
  e1 = _mm512_set_epi64(5, 7, 6, 6, 1, 3, 2, 2);
  check_equal_nd(&z2, &e1, 16, "_mm512_permutex_epi64", __LINE__);

  k = 0x7e;
  y2 = y1;
  y2 = _mm256_mask_permutex_epi64(y2, k, y2, 0x7a);
  e2 = _mm256_set_epi64x(1, 3, 2, 0);
  check_equal_nd(&y2, &e2, 8, "_mm256_mask_permutex_epi64", __LINE__);

  k = 0x7e;
  z2 = v1;
  z2 = _mm512_mask_permutex_epi64(z2, k, z2, 0x7a);
  e1 = _mm512_set_epi64(7, 7, 6, 6, 1, 3, 2, 0);
  check_equal_nd(&z2, &e1, 16, "_mm512_mask_permutex_epi64", __LINE__);

  k = 0x76;
  y2 = y1;
  y2 = _mm256_maskz_permutex_epi64(k, y2, 0x7a);
  e2 = _mm256_set_epi64x(0, 3, 2, 0);
  check_equal_nd(&y2, &e2, 8, "_mm256_maskz_permutex_epi64", __LINE__);

  k = 0x7e;
  z2 = v1;
  z2 = _mm512_maskz_permutex_epi64(k, z2, 0x7a);
  e1 = _mm512_set_epi64(0, 7, 6, 6, 1, 3, 2, 0);
  check_equal_nd(&z2, &e1, 16, "_mm512_maskz_permutex_epi64", __LINE__);
}

void NOINLINE do_perm_pd_imm() {
  __mmask8 k;

  volatile __m512i v1 = _mm512_set_epi64(7, 6, 5, 4, 3, 2, 1, 0);
  __m512d z1 = _mm512_castsi512_pd(v1);
  __m512d z2;
  __m512i e1;
  volatile __m256i yv1;
  __m256d y1;
  __m256d y2;
  __m256i ye1;

  z2 = _mm512_permutex_pd(z1, 0x7a);
  e1 = _mm512_set_epi64(5, 7, 6, 6, 1, 3, 2, 2);
  check_equal_nd(&z2, &e1, 16, "_mm512_permutex_pd", __LINE__);

  k = 0x7e;
  z2 = _mm512_castsi512_pd(v1);
  z2 = _mm512_mask_permutex_pd(z2, k, z2, 0x7a);
  e1 = _mm512_set_epi64(7, 7, 6, 6, 1, 3, 2, 0);
  check_equal_nd(&z2, &e1, 16, "_mm512_mask_permutex_pd", __LINE__);

  z2 = _mm512_castsi512_pd(v1);
  z2 = _mm512_maskz_permutex_pd(k, z2, 0x7a);
  e1 = _mm512_set_epi64(0, 7, 6, 6, 1, 3, 2, 0);
  check_equal_nd(&z2, &e1, 16, "_mm512_maskz_permutex_pd", __LINE__);

  /* 256 */
  yv1 = _mm256_set_epi64x(7, 6, 5, 4);
  y1 = _mm256_castsi256_pd(yv1);

  y2 = _mm256_permutex_pd(y1, 0xa);
  ye1 = _mm256_set_epi64x(4, 4, 6, 6);
  check_equal_nd(&y2, &ye1, 8, "_mm256_permutex_pd", __LINE__);

  k = 0x7e;
  y2 = _mm256_castsi256_pd(yv1);
  y2 = _mm256_mask_permutex_pd(y2, k, y2, 0xa);
  ye1 = _mm256_set_epi64x(4, 4, 6, 4);
  check_equal_nd(&y2, &ye1, 8, "_mm256_mask_permutex_pd", __LINE__);

  y2 = _mm256_castsi256_pd(yv1);
  y2 = _mm256_maskz_permutex_pd(k, y2, 0xa);
  ye1 = _mm256_set_epi64x(4, 4, 6, 0);
  check_equal_nd(&y2, &ye1, 8, "_mm256_maskz_permutex_pd", __LINE__);
}

void NOINLINE do_perm_ti_2w() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask32 k;

  res.zmmi = _mm512_permutex2var_epi16(i16.zmmi, i16_mix.zmmi, i16_big.zmmi);
  for (i = 0; i < 32; i++) {
    int index = i16_mix.s16[i] & 0x1f;
    expected.s16[i] =
        (i16_mix.s16[i] & 0x20) ? i16_big.s16[index] : i16.s16[index];
  }
  check_equal_nd(&res, &expected, 16, "_mm512_permutex2var_epi16", __LINE__);

  i16_big.xmmi[vol0] = i16_big.xmmi[vol0];

  k = 0xabcdffef;
  res.zmmi =
      _mm512_mask_permutex2var_epi16(i16.zmmi, k, i16_mix.zmmi, i16_big.zmmi);
  for (i = 0; i < 32; i++) {
    int index = i16_mix.s16[i] & 0x1f;
    expected.s16[i] =
        (i16_mix.s16[i] & 0x20) ? i16_big.s16[index] : i16.s16[index];
    if ((k & (1 << i)) == 0) {
      expected.s16[i] = i16.s16[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_permutex2var_epi16",
                 __LINE__);

  i16_big.xmmi[vol0] = i16_big.xmmi[vol0];

  k = 0xabcdffef;
  res.zmmi =
      _mm512_mask2_permutex2var_epi16(i16.zmmi, i16_mix.zmmi, k, i16_big.zmmi);
  for (i = 0; i < 32; i++) {
    int index = i16_mix.s16[i] & 0x1f;
    expected.s16[i] =
        (i16_mix.s16[i] & 0x20) ? i16_big.s16[index] : i16.s16[index];
    if ((k & (1 << i)) == 0) {
      expected.s16[i] = i16_mix.s16[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask2_permutex2var_epi16",
                 __LINE__);

  i16_big.xmmi[vol0] = i16_big.xmmi[vol0];

  k = 0xabcdffef;
  res.zmmi =
      _mm512_maskz_permutex2var_epi16(k, i16.zmmi, i16_mix.zmmi, i16_big.zmmi);
  for (i = 0; i < 32; i++) {
    int index = i16_mix.s16[i] & 0x1f;
    expected.s16[i] =
        (i16_mix.s16[i] & 0x20) ? i16_big.s16[index] : i16.s16[index];
    if ((k & (1 << i)) == 0) {
      expected.s16[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_permutex2var_epi16",
                 __LINE__);
}

void NOINLINE do_perm_ti_2d() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask16 k;

  res.zmmi = _mm512_permutex2var_epi32(i32.zmmi, i32_mix.zmmi, i32_big.zmmi);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
  }
  check_equal_nd(&res, &expected, 16, "_mm512_permutex2var_epi32", __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xabcd;
  res.zmmi =
      _mm512_mask_permutex2var_epi32(i32.zmmi, k, i32_mix.zmmi, i32_big.zmmi);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = i32.s32[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_permutex2var_epi32",
                 __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xdcba;
  res.zmmi =
      _mm512_mask2_permutex2var_epi32(i32.zmmi, i32_mix.zmmi, k, i32_big.zmmi);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = i32_mix.s32[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask2_permutex2var_epi32",
                 __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xabcd;
  res.zmmi =
      _mm512_maskz_permutex2var_epi32(k, i32.zmmi, i32_mix.zmmi, i32_big.zmmi);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_permutex2var_epi32",
                 __LINE__);
}

void NOINLINE do_perm_ti_2q() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k;

  res.zmmi = _mm512_permutex2var_epi64(i64.zmmi, i64_mix.zmmi, i64_big.zmmi);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
  }
  check_equal_nd(&res, &expected, 16, "_mm512_permutex2var_epi64", __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xf9;
  res.zmmi =
      _mm512_mask_permutex2var_epi64(i64.zmmi, k, i64_mix.zmmi, i64_big.zmmi);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = i64.s64[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_permutex2var_epi64",
                 __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xf9;
  res.zmmi =
      _mm512_mask2_permutex2var_epi64(i64.zmmi, i64_mix.zmmi, k, i64_big.zmmi);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = i64_mix.s64[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask2_permutex2var_epi64",
                 __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xe7;
  res.zmmi =
      _mm512_maskz_permutex2var_epi64(k, i64.zmmi, i64_mix.zmmi, i64_big.zmmi);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_permutex2var_epi64",
                 __LINE__);
}

void NOINLINE do_perm_ti_2ps() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask16 k;

  res.zmm = _mm512_permutex2var_ps(i32.zmm, i32_mix.zmmi, i32_big.zmm);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
  }
  check_equal_nd(&res, &expected, 16, "_mm512_permutex2var_ps", __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xabcd;
  res.zmm = _mm512_mask_permutex2var_ps(i32.zmm, k, i32_mix.zmmi, i32_big.zmm);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = i32.s32[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_permutex2var_ps", __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xabcd;
  res.zmm = _mm512_mask2_permutex2var_ps(i32.zmm, i32_mix.zmmi, k, i32_big.zmm);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = i32_mix.s32[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask2_permutex2var_ps", __LINE__);

  i32_big.xmmi[vol0] = i32_big.xmmi[vol0];

  k = 0xabcd;
  res.zmm = _mm512_maskz_permutex2var_ps(k, i32.zmm, i32_mix.zmmi, i32_big.zmm);
  for (i = 0; i < 16; i++) {
    int index = i32_mix.s32[i] & 0xf;
    expected.s32[i] =
        (i32_mix.s32[i] & 0x10) ? i32_big.s32[index] : i32.s32[index];
    if ((k & (1 << i)) == 0) {
      expected.s32[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_permutex2var_ps", __LINE__);
}

void NOINLINE do_perm_ti_2pd() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask8 k;

  res.zmmd = _mm512_permutex2var_pd(i64.zmmd, i64_mix.zmmi, i64_big.zmmd);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
  }
  check_equal_nd(&res, &expected, 16, "_mm512_permutex2var_pd", __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xf9;
  res.zmmd =
      _mm512_mask_permutex2var_pd(i64.zmmd, k, i64_mix.zmmi, i64_big.zmmd);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = i64.s64[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_permutex2var_pd", __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xf9;
  res.zmmd =
      _mm512_mask2_permutex2var_pd(i64.zmmd, i64_mix.zmmi, k, i64_big.zmmd);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = i64_mix.s64[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask2_permutex2var_pd", __LINE__);

  i64_big.xmmi[vol0] = i64_big.xmmi[vol0];

  k = 0xf9;
  res.zmmd =
      _mm512_maskz_permutex2var_pd(k, i64.zmmd, i64_mix.zmmi, i64_big.zmmd);
  for (i = 0; i < 8; i++) {
    int index = i64_mix.s64[i] & 0x7;
    expected.s64[i] =
        (i64_mix.s64[i] & 0x8) ? i64_big.s64[index] : i64.s64[index];
    if ((k & (1 << i)) == 0) {
      expected.s64[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_permutex2var_pd", __LINE__);
}

#define CHECK_PERMW(n_elems, dest, mask, zeroing, name)                        \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; i++) {                                            \
      expected.s16[i] = i16_mix.s16[i16.s16[i] & 0x1f];                        \
      if ((mask & (1 << i)) == 0) {                                            \
        if (zeroing) {                                                         \
          expected.s16[i] = 0;                                                 \
        } else {                                                               \
          expected.s16[i] = dest.s16[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems / 2, name, __LINE__);              \
    i16.xmmi[vol0] = i16.xmmi[vol0];                                           \
  }

void NOINLINE do_permw() {
  V512 res;
  V512 expected;
  __mmask32 k32 = 0xFFFFFFFF;

  res.xmmi[vol0] = _mm_permutexvar_epi16(i16.xmmi[vol0], i16_mix.xmmi[vol0]);
  CHECK_PERMW(8, i16_big, k32, 0, "_mm_permutexvar_epi16");

  res.ymmi[vol0] = _mm256_permutexvar_epi16(i16.ymmi[vol0], i16_mix.ymmi[vol0]);
  CHECK_PERMW(16, i16_big, k32, 0, "_mm256_permutexvar_epi16");

  res.zmmi = _mm512_permutexvar_epi16(i16.zmmi, i16_mix.zmmi);
  CHECK_PERMW(32, i16_big, k32, 0, "_mm512_permutexvar_epi16");

  k32 = 0xA4A4A4A4;
  res.xmmi[vol0] = _mm_mask_permutexvar_epi16(
      i16_big.xmmi[vol0], k32, i16.xmmi[vol0], i16_mix.xmmi[vol0]);
  CHECK_PERMW(8, i16_big, k32, 0, "_mm_mask_permutexvar_epi16");

  res.ymmi[vol0] = _mm256_mask_permutexvar_epi16(
      i16_big.ymmi[vol0], k32, i16.ymmi[vol0], i16_mix.ymmi[vol0]);
  CHECK_PERMW(16, i16_big, k32, 0, "_mm256_mask_permutexvar_epi16");

  res.zmmi =
      _mm512_mask_permutexvar_epi16(i16_big.zmmi, k32, i16.zmmi, i16_mix.zmmi);
  CHECK_PERMW(32, i16_big, k32, 0, "_mm512_mask_permutexvar_epi16");

  k32 = 0x4A4A4A4A;
  res.xmmi[vol0] =
      _mm_maskz_permutexvar_epi16(k32, i16.xmmi[vol0], i16_mix.xmmi[vol0]);
  CHECK_PERMW(8, i16_big, k32, 1, "_mm_maskz_permutexvar_epi16");

  res.ymmi[vol0] =
      _mm256_maskz_permutexvar_epi16(k32, i16.ymmi[vol0], i16_mix.ymmi[vol0]);
  CHECK_PERMW(16, i16_big, k32, 1, "_mm256_maskz_permutexvar_epi16");

  res.zmmi = _mm512_maskz_permutexvar_epi16(k32, i16.zmmi, i16_mix.zmmi);
  CHECK_PERMW(32, i16_big, k32, 1, "_mm512_maskz_permutexvar_epi16");
}

void NOINLINE do_blendmps() {
  V512 res;
  V512 expected;
  volatile int i;
  __mmask16 k = 0x3456;

  res.zmm = _mm512_mask_blend_ps(k, i32.zmm, i32_mix.zmm);
  for (i = 0; i < 16; i++) {
    expected.s32[i] = i32.s32[i];
    if ((k & (1 << i)) != 0) {
      expected.s32[i] = i32_mix.s32[i];
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_blend_ps", __LINE__);
}

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

  do_pshufb();

  do_perm_epi32();
  do_perm_ps();
  do_permi_ps();

  do_perm_epi64();
  do_perm_pd();
  do_permi_pd();

  do_perm_epi64_imm();
  do_perm_pd_imm();

  do_perm_ti_2w();

  do_perm_ti_2d();
  do_perm_ti_2q();

  do_perm_ti_2ps();
  do_perm_ti_2pd();

  do_permw();

  do_blendmps();

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

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