/*
 * Test math instructions: sqrt, reciprocal, floor, ceil, exponent,
 *                          scale, fixup ,roundscale and ternary logic.
 * Here we check for _mm512_[mask|maskz]_[ceil|floor|scalef|sqrt|ternarylogic]
 * intrinsics.
 */
#include "m512_test_util.h"
#include <math.h>
#include <stdio.h>
#include <string.h>

volatile int vol0 = 0;

V512 i32;
V512 i32_squares;
V512 i32_neg;
V512 i64;
V512 i64_squares;
V512 i64_neg;
V512 f32;
V512 f32_squares;
V512 f32_halves;
V512 f64;
V512 f64_squares;
V512 f64_halves;

void NOINLINE init() {
  volatile int i;

  for (i = 0; i < 16; i++) {
    i32.s32[i] = i;
    i32_squares.s32[i] = i * i;
    i32_neg.s32[i] = -i;
    f32.f32[i] = i;
    f32_squares.f32[i] = i * i;
    f32_halves.f32[i] = i + 0.5f;
  }

  for (i = 0; i < 8; i++) {
    i64.s64[i] = i;
    i64_squares.s64[i] = i * i;
    i64_neg.s64[i] = -i;
    f64.f64[i] = i;
    f64_squares.f64[i] = i * i;
    f64_halves.f64[i] = i + 0.5;
  }
}

void NOINLINE do_rcp14pd() {
  volatile V512 res;
  V512 expected;
  __mmask8 k = 0xc3;

  res.zmmd = _mm512_rcp14_pd(f64.zmmd);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_mask_rcp14_pd(res.zmmd, k, f64.zmmd);
}

void NOINLINE do_rcp14ps() {
  volatile V512 res;
  V512 expected;
  __mmask16 k = 0x7e95;

  res.zmm = _mm512_rcp14_ps(f32.zmm);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_mask_rcp14_ps(res.zmm, k, f32.zmm);
}

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

  res.zmm = _mm512_sqrt_ps(f32_squares.zmm);
  for (i = 0; i < 16; i++) {
    expected.f32[i] = i;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_sqrt_ps", __LINE__);

  f32_squares.xmm[vol0] = f32_squares.xmm[vol0]; /* No-op. */

  k = 0xbcdf;
  res.zmm = _mm512_setzero_ps();
  res.zmm = _mm512_mask_sqrt_ps(res.zmm, k, f32_squares.zmm);
  expected.zmm = _mm512_setzero_ps();
  for (i = 0; i < 16; i++) {
    if (k & (1 << i)) {
      expected.f32[i] = i;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_sqrt_ps", __LINE__);
}

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

  res.zmmd = _mm512_sqrt_pd(f64_squares.zmmd);
  for (i = 0; i < 8; i++) {
    expected.f64[i] = i;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_sqrt_pd", __LINE__);

  f64_squares.xmmd[vol0] = f64_squares.xmmd[vol0]; /* No-op. */

  k = 0xe9;
  res.zmmd = _mm512_setzero_pd();
  res.zmmd = _mm512_mask_sqrt_pd(res.zmmd, k, f64_squares.zmmd);
  expected.zmmd = _mm512_setzero_pd();
  for (i = 0; i < 8; i++) {
    if (k & (1 << i)) {
      expected.f64[i] = i;
    }
  }

  check_equal_nd(&res, &expected, 16, "_mm512_mask_sqrt_pd", __LINE__);
}

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

  res.zmm = _mm512_floor_ps(f32_halves.zmm);
  for (i = 0; i < 16; i++) {
    expected.f32[i] = i;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_floor_ps", __LINE__);

  f32_halves.xmm[vol0] = f32_halves.xmm[vol0]; /* No-op. */

  k = 0xbcdf;
  res.zmm = _mm512_setzero_ps();
  res.zmm = _mm512_mask_floor_ps(res.zmm, k, f32_halves.zmm);
  expected.zmm = _mm512_setzero_ps();
  for (i = 0; i < 16; i++) {
    if (k & (1 << i)) {
      expected.f32[i] = i;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_floor_ps", __LINE__);
}

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

  res.zmmd = _mm512_floor_pd(f64_halves.zmmd);
  for (i = 0; i < 8; i++) {
    expected.f64[i] = i;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_floor_pd", __LINE__);

  f64_halves.xmmd[vol0] = f64_halves.xmmd[vol0]; /* No-op. */

  k = 0x7b;
  res.zmmd = _mm512_setzero_pd();
  res.zmmd = _mm512_mask_floor_pd(res.zmmd, k, f64_halves.zmmd);
  expected.zmmd = _mm512_setzero_pd();
  for (i = 0; i < 8; i++) {
    if (k & (1 << i)) {
      expected.f64[i] = i;
    }
  }

  check_equal_nd(&res, &expected, 16, "_mm512_mask_floor_pd", __LINE__);
}

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

  res.zmm = _mm512_ceil_ps(f32_halves.zmm);
  for (i = 0; i < 16; i++) {
    expected.f32[i] = i + 1;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_ceil_ps", __LINE__);

  f32_halves.xmm[vol0] = f32_halves.xmm[vol0]; /* No-op. */

  k = 0xbcdf;
  res.zmm = _mm512_setzero_ps();
  res.zmm = _mm512_mask_ceil_ps(res.zmm, k, f32_halves.zmm);
  expected.zmm = _mm512_setzero_ps();
  for (i = 0; i < 16; i++) {
    if (k & (1 << i)) {
      expected.f32[i] = i + 1;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_ceil_ps", __LINE__);
}

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

  res.zmmd = _mm512_ceil_pd(f64_halves.zmmd);
  for (i = 0; i < 8; i++) {
    expected.f64[i] = i + 1;
  }
  check_equal_nd(&res, &expected, 16, "_mm512_ceil_pd", __LINE__);

  f64_halves.xmmd[vol0] = f64_halves.xmmd[vol0]; /* No-op. */

  k = 0x7b;
  res.zmmd = _mm512_setzero_pd();
  res.zmmd = _mm512_mask_ceil_pd(res.zmmd, k, f64_halves.zmmd);
  expected.zmmd = _mm512_setzero_pd();
  for (i = 0; i < 8; i++) {
    if (k & (1 << i)) {
      expected.f64[i] = i + 1;
    }
  }

  check_equal_nd(&res, &expected, 16, "_mm512_mask_ceil_pd", __LINE__);
}

void NOINLINE do_getexpsd() {
  __mmask8 k8 = 0x2;
  volatile __m128d res;
  volatile __m128d v1 = _mm_set_pd(8.0, 32.0);
  volatile __m128d v2 = _mm_set_pd(16.0, 64.0);

  __m128d res_exp_nomask = _mm_set_pd(8.0, 6.0);
  __m128d res_exp_mask = _mm_set_pd(8.0, 32.0);
  __m128d res_exp_maskz = _mm_set_pd(8.0, 0.0);

  res = _mm_setzero_pd();
  res = _mm_getexp_sd(v1, v2);

  check_equal_ndf((void *)&res, (void *)&res_exp_nomask, 2, "_mm_getexp_sd",
                  __LINE__);

  res = _mm_setzero_pd();
  res = _mm_mask_getexp_sd(v1, k8, v1, v2);
  check_equal_ndf((void *)&res, (void *)&res_exp_mask, 2, "_mm_mask_getexp_sd",
                  __LINE__);

  res = _mm_setzero_pd();
  res = _mm_maskz_getexp_sd(k8, v1, v2);
  check_equal_ndf((void *)&res, (void *)&res_exp_maskz, 2,
                  "_mm_maskz_getexp_sd", __LINE__);
}

void NOINLINE do_getexpss() {
  __mmask8 k8 = 0xe;
  volatile __m128 res;
  volatile __m128 v1 = _mm_set_ps(16.0f, 32.0f, 64.0f, 128.0f);
  volatile __m128 v2 = _mm_set_ps(128.0f, 256.0f, 512.0f, 1024.0f);

  volatile __m128 res_exp_nomask = _mm_set_ps(16.0f, 32.0f, 64.0f, 10.0f);
  volatile __m128 res_exp_mask = _mm_set_ps(16.0f, 32.0f, 64.0f, 128.0f);
  volatile __m128 res_exp_maskz = _mm_set_ps(16.0f, 32.0f, 64.0f, 0.0f);

  res = _mm_setzero_ps();
  res = _mm_getexp_ss(v1, v2);
  check_equal_nsf((void *)&res, (void *)&res_exp_nomask, 4, "_mm_getexp_ss",
                  __LINE__);

  res = _mm_setzero_ps();
  res = _mm_mask_getexp_ss(v1, k8, v1, v2);
  check_equal_nsf((void *)&res, (void *)&res_exp_mask, 2, "_mm_mask_getexp_ss",
                  __LINE__);

  res = _mm_setzero_ps();
  res = _mm_maskz_getexp_ss(k8, v1, v2);
  check_equal_nsf((void *)&res, (void *)&res_exp_maskz, 4,
                  "_mm_maskz_getexp_ss", __LINE__);
}

void NOINLINE do_getmantpd() {
  volatile V512 res;
  V512 expected;
  __mmask8 k = 0x75;

  res.zmmd =
      _mm512_getmant_pd(f64.zmmd, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_zero);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_mask_getmant_pd(res.zmmd, k, f64.zmmd, _MM_MANT_NORM_p5_2,
                                    _MM_MANT_SIGN_zero);
}

void NOINLINE do_getmantps() {
  volatile V512 res;
  V512 expected;
  __mmask16 k = 0x7e95;

  res.zmm = _mm512_getmant_ps(f32.zmm, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_zero);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_mask_getmant_ps(res.zmm, k, f32.zmm, _MM_MANT_NORM_p5_2,
                                   _MM_MANT_SIGN_zero);
}

#define CHECK_SCALEFPD(n_elems, dest, mask, zeroing, name)                     \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; i++) {                                            \
      expected.f64[i] = f64.f64[i] * (pow(2.0, floor(f64_squares.f64[i])));    \
      if ((mask & (1 << i)) == 0) {                                            \
        if (zeroing) {                                                         \
          expected.f64[i] = 0.0;                                               \
        } else {                                                               \
          expected.f64[i] = dest.f64[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems * 2, name, __LINE__);              \
    f64.xmmd[vol0] = f64.xmmd[vol0];                                           \
  }

void NOINLINE do_scalefpd() {
  V512 res;
  V512 expected;
  __mmask8 k = 0xFF;

  res.zmmd = _mm512_scalef_round_pd(f64.zmmd, f64_squares.zmmd,
                                    _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPD(8, f64_halves, k, 0, "_mm512_scalef_round_pd");

  res.zmmd = _mm512_scalef_pd(f64.zmmd, f64_squares.zmmd);
  CHECK_SCALEFPD(8, f64_halves, k, 0, "_mm512_scalef_pd");

  k = 0x75;

  res.zmmd = _mm512_mask_scalef_round_pd(
      f64_halves.zmmd, k, f64.zmmd, f64_squares.zmmd,
      _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPD(8, f64_halves, k, 0, "_mm512_mask_scalef_round_pd");

  res.zmmd =
      _mm512_mask_scalef_pd(f64_halves.zmmd, k, f64.zmmd, f64_squares.zmmd);
  CHECK_SCALEFPD(8, f64_halves, k, 0, "_mm512_mask_scalef_pd");

  k = 0x57;

  res.zmmd = _mm512_maskz_scalef_round_pd(
      k, f64.zmmd, f64_squares.zmmd, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPD(8, f64_halves, k, 1, "_mm512_maskz_scalef_round_pd");

  res.zmmd = _mm512_maskz_scalef_pd(k, f64.zmmd, f64_squares.zmmd);
  CHECK_SCALEFPD(8, f64_halves, k, 1, "_mm512_maskz_scalef_pd");
}

#define CHECK_SCALEFPS(n_elems, dest, mask, zeroing, name)                     \
  {                                                                            \
    volatile int i;                                                            \
    for (i = 0; i < n_elems; i++) {                                            \
      expected.f32[i] = f32.f32[i] * (powf(2.0F, floorf(f32_squares.f32[i]))); \
      if ((mask & (1 << i)) == 0) {                                            \
        if (zeroing) {                                                         \
          expected.f32[i] = 0.0F;                                              \
        } else {                                                               \
          expected.f32[i] = dest.f32[i];                                       \
        }                                                                      \
      }                                                                        \
    }                                                                          \
    check_equal_nd(&res, &expected, n_elems, name, __LINE__);                  \
    f32.xmm[vol0] = f32.xmm[vol0];                                             \
  }

void NOINLINE do_scalefps() {
  V512 res;
  V512 expected;
  __mmask16 k = 0xFFFF;

  res.zmm = _mm512_scalef_round_ps(f32.zmm, f32_squares.zmm,
                                   _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPS(16, f32_halves, k, 0, "_mm512_scalef_round_ps");

  res.zmm = _mm512_scalef_ps(f32.zmm, f32_squares.zmm);
  CHECK_SCALEFPS(16, f32_halves, k, 0, "_mm512_scalef_ps");

  k = 0x0bcd;

  res.zmm =
      _mm512_mask_scalef_round_ps(f32_halves.zmm, k, f32.zmm, f32_squares.zmm,
                                  _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPS(16, f32_halves, k, 0, "_mm512_mask_scalef_round_ps");

  res.zmm = _mm512_mask_scalef_ps(f32_halves.zmm, k, f32.zmm, f32_squares.zmm);
  CHECK_SCALEFPS(16, f32_halves, k, 0, "_mm512_mask_scalef_ps");

  k = 0x0dcb;

  res.zmm = _mm512_maskz_scalef_round_ps(
      k, f32.zmm, f32_squares.zmm, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
  CHECK_SCALEFPS(16, f32_halves, k, 1, "_mm512_maskz_scalef_round_ps");

  res.zmm = _mm512_maskz_scalef_ps(k, f32.zmm, f32_squares.zmm);
  CHECK_SCALEFPS(16, f32_halves, k, 1, "_mm512_maskz_scalef_ps");
}

#define SOME_ROUND (_MM_FROUND_CUR_DIRECTION)

void NOINLINE do_fixupimmpd() {
  volatile V512 res;
  V512 expected;
  __mmask8 k = 0x75;

  res.zmmd = _mm512_fixupimm_pd(f64.zmmd, f64_squares.zmmd, i32.zmmi, 0x97);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_mask_fixupimm_pd(res.zmmd, k, f64.zmmd, i32.zmmi, 0xfe);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_maskz_fixupimm_pd(k, res.zmmd, f64.zmmd, i32.zmmi, 0xfe);

  res.zmmd = _mm512_fixupimm_round_pd(f64.zmmd, f64_squares.zmmd, i32.zmmi,
                                      0x97, SOME_ROUND);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_mask_fixupimm_round_pd(res.zmmd, k, f64.zmmd, i32.zmmi,
                                           0xfe, SOME_ROUND);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_maskz_fixupimm_round_pd(k, res.zmmd, f64.zmmd, i32.zmmi,
                                            0xfe, SOME_ROUND);
}

void NOINLINE do_fixupimmps() {
  volatile V512 res;
  V512 expected;
  __mmask16 k = 0x75;

  res.zmm = _mm512_fixupimm_ps(f32.zmm, f32_squares.zmm, i32.zmmi, 0x97);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_mask_fixupimm_ps(res.zmm, k, f32.zmm, i32.zmmi, 0xfe);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_maskz_fixupimm_ps(k, res.zmm, f32.zmm, i32.zmmi, 0xfe);

  res.zmm = _mm512_fixupimm_round_ps(f32.zmm, f32_squares.zmm, i32.zmmi, 0x97,
                                     SOME_ROUND);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_mask_fixupimm_round_ps(res.zmm, k, f32.zmm, i32.zmmi, 0xfe,
                                          SOME_ROUND);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_maskz_fixupimm_round_ps(k, res.zmm, f32.zmm, i32.zmmi, 0xfe,
                                           SOME_ROUND);
}

void NOINLINE do_fixupimmsd() {
  volatile V512 res;
  V512 expected;

  __mmask8 k = 0x75;

  res.xmmd[0] =
      _mm_fixupimm_sd(f64.xmmd[0], f64_squares.xmmd[0], i32.xmmi[0], 0x97);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmmd[0] =
      _mm_mask_fixupimm_sd(res.xmmd[0], k, f64.xmmd[0], i32.xmmi[0], 0xfe);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmmd[0] =
      _mm_maskz_fixupimm_sd(k, res.xmmd[0], f64.xmmd[0], i32.xmmi[0], 0xfe);

  res.xmmd[0] = _mm_fixupimm_round_sd(f64.xmmd[0], f64_squares.xmmd[0],
                                      i32.xmmi[0], 0x97, SOME_ROUND);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmmd[0] = _mm_mask_fixupimm_round_sd(res.xmmd[0], k, f64.xmmd[0],
                                           i32.xmmi[0], 0xfe, SOME_ROUND);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmmd[0] = _mm_maskz_fixupimm_round_sd(k, res.xmmd[0], f64.xmmd[0],
                                            i32.xmmi[0], 0xfe, SOME_ROUND);
}

void NOINLINE do_fixupimmss() {
  volatile V512 res;
  V512 expected;
  __mmask8 k = 0x75;

  res.xmm[0] =
      _mm_fixupimm_ss(f32.xmm[0], f32_squares.xmm[0], i32.xmmi[0], 0x97);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmm[0] =
      _mm_mask_fixupimm_ss(res.xmm[0], k, f32.xmm[0], i32.xmmi[0], 0xfe);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmm[0] =
      _mm_maskz_fixupimm_ss(k, res.xmm[0], f32.xmm[0], i32.xmmi[0], 0xfe);

  res.xmm[0] = _mm_fixupimm_round_ss(f64.xmm[0], f64_squares.xmm[0],
                                     i32.xmmi[0], 0x97, SOME_ROUND);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmm[0] = _mm_mask_fixupimm_round_ss(res.xmm[0], k, f64.xmm[0],
                                          i32.xmmi[0], 0xfe, SOME_ROUND);

  res.xmmi[0] = _mm_setzero_si128();
  res.xmm[0] = _mm_maskz_fixupimm_round_ss(k, res.xmm[0], f64.xmm[0],
                                           i32.xmmi[0], 0xfe, SOME_ROUND);
}

void NOINLINE do_roundscalepd() {
  volatile V512 res;
  V512 expected;
  __mmask16 k = 0x3d;

  res.zmmd = _mm512_roundscale_pd(f64.zmmd, 0xff);

  res.zmmi = _mm512_setzero_epi32();
  res.zmmd = _mm512_mask_roundscale_pd(res.zmmd, k, f64.zmmd, 0x36);
}

void NOINLINE do_roundscaleps() {
  volatile V512 res;
  V512 expected;
  __mmask16 k = 0x74cb;

  res.zmm = _mm512_roundscale_ps(f32.zmm, 0xf7);

  res.zmmi = _mm512_setzero_epi32();
  res.zmm = _mm512_mask_roundscale_ps(res.zmm, k, f32.zmm, 0x36);
}

static int NOINLINE emulate_ternarylogicd(int a, int b, int c, int imm) {
  int i, index, res = 0;

  for (i = 0; i < 32; i++) {
    index = ((a & 1) << 2) | ((b & 1) << 1) | (c & 1);
    res |= ((imm & (1 << index)) ? 1 : 0) << i;
    a >>= 1;
    b >>= 1;
    c >>= 1;
  }

  return res;
}

void NOINLINE do_pternlogq() {
  volatile int i;
  V512 res, resx, resy;
  V512 expected;
  __mmask8 k8 = 0x75;

  res.zmmi =
      _mm512_ternarylogic_epi64(i64.zmmi, i64_squares.zmmi, i64.zmmi, 0x79);
  for (i = 0; i < 16; i++) {
    expected.s32[i] =
        emulate_ternarylogicd(i64.s32[i], i64_squares.s32[i], i64.s32[i], 0x79);
  }
  check_equal_nd(&res, &expected, 16, "_mm512_ternarylogic_epi64", __LINE__);

  i64.xmm[vol0] = i64.xmm[vol0]; /* No-op. */

  res.zmmi = _mm512_setzero_epi32();
  res.zmmi = _mm512_mask_ternarylogic_epi64(res.zmmi, k8, i64_neg.zmmi,
                                            i64.zmmi, 0xca);
  for (i = 0; i < 16; i += 2) {
    if (k8 & (1 << (i / 2))) {
      expected.s32[i] =
          emulate_ternarylogicd(0, i64_neg.s32[i], i64.s32[i], 0xca);
      expected.s32[i + 1] =
          emulate_ternarylogicd(0, i64_neg.s32[i + 1], i64.s32[i + 1], 0xca);
    } else {
      expected.s32[i] = 0;
      expected.s32[i + 1] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_ternarylogic_epi64",
                 __LINE__);

  i64.xmm[vol0] = i64.xmm[vol0]; /* No-op. */

  res.zmmi = _mm512_maskz_ternarylogic_epi64(k8, i64_squares.zmmi,
                                             i64_squares.zmmi, i64.zmmi, 0x3b);
  for (i = 0; i < 16; i += 2) {
    if (k8 & (1 << (i / 2))) {
      expected.s32[i] = emulate_ternarylogicd(
          i64_squares.s32[i], i64_squares.s32[i], i64.s32[i], 0x3b);
      expected.s32[i + 1] = emulate_ternarylogicd(
          i64_squares.s32[i + 1], i64_squares.s32[i + 1], i64.s32[i], 0x3b);
    } else {
      expected.s32[i] = 0;
      expected.s32[i + 1] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_ternarylogic_epi64",
                 __LINE__);
}

void NOINLINE do_pternlogd() {
  volatile int i;
  V512 res, resx, resy;
  V512 expected;
  __mmask16 k = 0x23bc;
  __mmask8 k8 = (__mmask8)k;

  res.zmmi =
      _mm512_ternarylogic_epi32(i32.zmmi, i32_squares.zmmi, i32.zmmi, 0x97);
  for (i = 0; i < 16; i++) {
    expected.s32[i] =
        emulate_ternarylogicd(i32.s32[i], i32_squares.s32[i], i32.s32[i], 0x97);
  }
  check_equal_nd(&res, &expected, 16, "_mm512_ternarylogic_epi32", __LINE__);

  i32.xmm[vol0] = i32.xmm[vol0]; /* No-op. */

  res.zmmi = _mm512_setzero_epi32();
  res.zmmi = _mm512_mask_ternarylogic_epi32(res.zmmi, k, i32_squares.zmmi,
                                            i32.zmmi, 0xfe);
  for (i = 0; i < 16; i++) {
    if (k & (1 << i)) {
      expected.s32[i] =
          emulate_ternarylogicd(0, i32_squares.s32[i], i32.s32[i], 0xfe);
    } else {
      expected.s32[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_mask_ternarylogic_epi32",
                 __LINE__);

  i32.xmm[vol0] = i32.xmm[vol0]; /* No-op. */

  k = 0xabcd;
  k8 = (__mmask8)k;
  res.zmmi = _mm512_maskz_ternarylogic_epi32(k, i32_squares.zmmi, i32_neg.zmmi,
                                             i32.zmmi, 0x3b);
  for (i = 0; i < 16; i++) {
    if (k & (1 << i)) {
      expected.s32[i] = emulate_ternarylogicd(i32_squares.s32[i],
                                              i32_neg.s32[i], i32.s32[i], 0x3b);
    } else {
      expected.s32[i] = 0;
    }
  }
  check_equal_nd(&res, &expected, 16, "_mm512_maskz_ternarylogic_epi32",
                 __LINE__);
}

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

  do_rcp14pd();
  do_rcp14ps();

  do_sqrtps();
  do_sqrtpd();

  do_floorps();
  do_floorpd();

  do_ceilps();
  do_ceilpd();

  do_getexpsd();
  do_getexpss();

  do_getmantpd();
  do_getmantps();

  do_scalefpd();
  do_scalefps();

  do_fixupimmpd();
  do_fixupimmps();

  do_fixupimmsd();
  do_fixupimmss();

  do_roundscalepd();
  do_roundscaleps();

  do_pternlogq();
  do_pternlogd();

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

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