#include "m512_test_util.h"
#include <math.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>

/*
 * Test reduce instructions.
 * Here we check for _mm512_[mask_]reduce_[add|mul|min|max|and|or] intrinsics.
 */

typedef long long s64;
typedef unsigned long long u64;

typedef float f32;
typedef double f64;

typedef int s32;
typedef unsigned int u32;

int verbose = 0;
#define VERBOSE (verbose > 1)
#define SHOW_OP (verbose > 2)

typedef enum {
  ASSIGN,
  ADD,
  REDUCE_ADD,
  REDUCE_MUL,
  REDUCE_MIN,
  REDUCE_MAX,
  REDUCE_GMIN,
  REDUCE_GMAX,
  REDUCE_OR,
  REDUCE_AND
} OPER;

__mmask16 mask_true = 0xffff;

#define MASK(mask, n) ((mask & (0x1 << n)) != 0)

#define IMin(i, j) (((i) <= (j)) ? (i) : (j))
#define IMax(i, j) (((i) >= (j)) ? (i) : (j))

#define MULOP(a, b) (a * b)
#define ADDOP(a, b) (a + b)
#define OROP(a, b) (a | b)
#define ANDOP(a, b) (a & b)
#define GMINOP(a, b) fmin(a, b)
#define GMAXOP(a, b) fmax(a, b)

#define DO_MASK_COPY(len, output, mask, input, def)                            \
  {                                                                            \
    int n;                                                                     \
                                                                               \
    for (n = 0; n < len; n += 1) {                                             \
      if (MASK(mask, n)) {                                                     \
        output[n] = input[n];                                                  \
      } else {                                                                 \
        output[n] = def;                                                       \
      }                                                                        \
    }                                                                          \
  }

#define DO_REDUCE_16(res, mask, input, dtype, oper, initval)                   \
  {                                                                            \
    dtype dtype##tmp[4];                                                       \
    V512 vtmp;                                                                 \
    DO_MASK_COPY(16, vtmp.dtype, mask, input, initval);                        \
                                                                               \
    dtype##tmp[0] = oper(vtmp.dtype[0], vtmp.dtype[4]);                        \
    dtype##tmp[1] = oper(vtmp.dtype[1], vtmp.dtype[5]);                        \
    dtype##tmp[2] = oper(vtmp.dtype[2], vtmp.dtype[6]);                        \
    dtype##tmp[3] = oper(vtmp.dtype[3], vtmp.dtype[7]);                        \
                                                                               \
    dtype##tmp[0] = oper(dtype##tmp[0], vtmp.dtype[8]);                        \
    dtype##tmp[1] = oper(dtype##tmp[1], vtmp.dtype[9]);                        \
    dtype##tmp[2] = oper(dtype##tmp[2], vtmp.dtype[10]);                       \
    dtype##tmp[3] = oper(dtype##tmp[3], vtmp.dtype[11]);                       \
                                                                               \
    dtype##tmp[0] = oper(dtype##tmp[0], vtmp.dtype[12]);                       \
    dtype##tmp[1] = oper(dtype##tmp[1], vtmp.dtype[13]);                       \
    dtype##tmp[2] = oper(dtype##tmp[2], vtmp.dtype[14]);                       \
    dtype##tmp[3] = oper(dtype##tmp[3], vtmp.dtype[15]);                       \
                                                                               \
    dtype##tmp[0] = oper(dtype##tmp[0], dtype##tmp[1]);                        \
    dtype##tmp[2] = oper(dtype##tmp[2], dtype##tmp[3]);                        \
                                                                               \
    res = oper(dtype##tmp[0], dtype##tmp[2]);                                  \
  }

#define DO_REDUCE_8(res, mask, input, dtype, oper, initval)                    \
  {                                                                            \
    dtype dtype##tmp[4];                                                       \
    V512 vtmp;                                                                 \
    DO_MASK_COPY(8, vtmp.dtype, mask, input, initval);                         \
                                                                               \
    dtype##tmp[0] = oper(vtmp.dtype[0], vtmp.dtype[4]);                        \
    dtype##tmp[1] = oper(vtmp.dtype[1], vtmp.dtype[5]);                        \
    dtype##tmp[2] = oper(vtmp.dtype[2], vtmp.dtype[6]);                        \
    dtype##tmp[3] = oper(vtmp.dtype[3], vtmp.dtype[7]);                        \
                                                                               \
    dtype##tmp[0] = oper(dtype##tmp[0], dtype##tmp[1]);                        \
    dtype##tmp[2] = oper(dtype##tmp[2], dtype##tmp[3]);                        \
                                                                               \
    res = oper(dtype##tmp[0], dtype##tmp[2]);                                  \
  }

static int NOINLINE mask_s32_reduce_op(OPER op, __mmask16 mask,
                                       int s32op1[16]) {
  int handled = 0;
  int res;

  switch (op) {

  case REDUCE_ADD:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, ADDOP, 0);
    break;

  case REDUCE_MUL:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, MULOP, 1);
    break;

  case REDUCE_MIN:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, IMin, 0x7fffffff);
    break;

  case REDUCE_MAX:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, IMax, 0x80000000);
    break;

  case REDUCE_OR:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, OROP, 0);
    break;

  case REDUCE_AND:
    handled = 1;
    DO_REDUCE_16(res, mask, s32op1, s32, ANDOP, 0xffffffff);
    break;

  default:
    printf("FAIL: mask_s32_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_s32_reduce_op: unsupported op\n");
  }
  return (res);
}

static int NOINLINE mask_u32_reduce_op(OPER op, __mmask16 mask,
                                       u32 u32op1[16]) {
  int handled = 0;
  int res;

  switch (op) {

  case REDUCE_MIN:
    handled = 1;
    DO_REDUCE_16(res, mask, u32op1, u32, IMin, 0xffffffff);
    break;

  case REDUCE_MAX:
    handled = 1;
    DO_REDUCE_16(res, mask, u32op1, u32, IMax, 0x00000000);
    break;

  default:
    printf("FAIL: mask_u32_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_u32_reduce_op: unsupported op\n");
  }
  return (res);
}

static void NOINLINE init_s32(int s32out[16], int s32op1[16]) {
  int i = 0;
  for (i = 0; i < 16; i++) {
    s32out[i] = s32op1[i];
  }
}

static void NOINLINE init_f32(float f32out[16], float f32op1[16]) {
  int i = 0;
  for (i = 0; i < 16; i++) {
    f32out[i] = f32op1[i];
  }
}

static float NOINLINE mask_f32_reduce_op(OPER op, __mmask16 mask,
                                         float valop1[16]) {
  int handled = 0;
  float res;
  union {
    float f32init;
    int s32init;
  } init;

  switch (op) {

  case REDUCE_ADD:
    handled = 1;
    DO_REDUCE_16(res, mask, valop1, f32, ADDOP, 0.0);
    break;

  case REDUCE_MUL:
    handled = 1;
    DO_REDUCE_16(res, mask, valop1, f32, MULOP, 1.0);
    break;

  case REDUCE_GMIN:
    handled = 1;
    init.s32init = 0x7f800000; /* +inf */
    DO_REDUCE_16(res, mask, valop1, f32, GMINOP, init.f32init);
    break;

  case REDUCE_GMAX:
    handled = 1;
    init.s32init = 0xff800000; /* -inf */
    DO_REDUCE_16(res, mask, valop1, f32, GMAXOP, init.f32init);
    break;

  default:
    printf("FAIL: mask_f32_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_f32_reduce_op: unsupported op\n");
  }
  return (res);
}

static void NOINLINE init_f64(double f64out[8], double f64op1[8]) {
  int i = 0;
  for (i = 0; i < 8; i++) {
    f64out[i] = f64op1[i];
  }
}

static double NOINLINE mask_f64_reduce_op(OPER op, __mmask16 mask,
                                          double valop1[8]) {
  int handled = 0;
  double res;
  union {
    double f64init;
    int s32init[2];
  } init;

  switch (op) {

  case REDUCE_ADD:
    handled = 1;
    DO_REDUCE_8(res, mask, valop1, f64, ADDOP, 0.0);
    break;

  case REDUCE_MUL:
    handled = 1;
    DO_REDUCE_8(res, mask, valop1, f64, MULOP, 1.0);
    break;

  case REDUCE_GMIN:
    handled = 1;
    init.s32init[0] = 0x00000000; /* +inf */
    init.s32init[1] = 0x7ff00000; /* +inf */
    DO_REDUCE_8(res, mask, valop1, f64, GMINOP, init.f64init);
    break;

  case REDUCE_GMAX:
    handled = 1;
    init.s32init[0] = 0x00000000; /* -inf */
    init.s32init[1] = 0xfff00000; /* -inf */
    DO_REDUCE_8(res, mask, valop1, f64, GMAXOP, init.f64init);
    break;

  default:
    printf("FAIL: mask_f64_reduce_op: bad op\n");
    exit(1);
    break;
  }
  if (!handled) {
    printf("FAIL: mask_f64_reduce_op: unsupported op\n");
  }
  return (res);
}

static void NOINLINE print_s32(char *pfx, int var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%5d", var);
  printf("\n");
}

static void NOINLINE print_u32(char *pfx, u32 var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%5u", var);
  printf("\n");
}

static void NOINLINE print_f32(char *pfx, float var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%5.2f", var);
  printf("\n");
}

static void NOINLINE print_f64(char *pfx, double var) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  printf("%5.2lf", var);
  printf("\n");
}

static void NOINLINE print_ivec(char *pfx, int ivec[]) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  char *fmt = "%5d %5d %5d %5d ";
  printf(fmt, ivec[15], ivec[14], ivec[13], ivec[12]);
  printf(fmt, ivec[11], ivec[10], ivec[9], ivec[8]);
  printf(fmt, ivec[7], ivec[6], ivec[5], ivec[4]);
  printf(fmt, ivec[3], ivec[2], ivec[1], ivec[0]);
  printf("\n");
}

static void NOINLINE print_uvec(char *pfx, u32 ivec[]) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  char *fmt = "%5u %5u %5u %5u ";
  printf(fmt, ivec[15], ivec[14], ivec[13], ivec[12]);
  printf(fmt, ivec[11], ivec[10], ivec[9], ivec[8]);
  printf(fmt, ivec[7], ivec[6], ivec[5], ivec[4]);
  printf(fmt, ivec[3], ivec[2], ivec[1], ivec[0]);
  printf("\n");
}

static void NOINLINE print_fvec(char *pfx, float fvec[]) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  char *fmt = "%5.2f %5.2f %5.2f %5.2f ";
  printf(fmt, fvec[15], fvec[14], fvec[13], fvec[12]);
  printf(fmt, fvec[11], fvec[10], fvec[9], fvec[8]);
  printf(fmt, fvec[7], fvec[6], fvec[5], fvec[4]);
  printf(fmt, fvec[3], fvec[2], fvec[1], fvec[0]);
  printf("\n");
}

static void NOINLINE print_dvec(char *pfx, double dvec[]) {
  if (pfx) {
    printf("%s: ", pfx);
  }
  char *fmt = "%5.2lf %5.2lf %5.2lf %5.2lf ";
  printf(fmt, dvec[7], dvec[6], dvec[5], dvec[4]);
  printf(fmt, dvec[3], dvec[2], dvec[1], dvec[0]);
  printf("\n");
}

#define PRINT_MASK(bits, width, pfx, var)                                      \
  print_mask(bits, "%" #width "d ", pfx, var)

static void NOINLINE print_mask(int bits, char *fmt, char *pfx,
                                __mmask16 mask) {
  int i;
  if (pfx) {
    printf("%s: ", pfx);
  }
  for (i = bits; i >= 1; i -= 1) {
    printf(fmt, MASK(mask, (i - 1)));
  }
  printf("\n");
}

#define CHECK_PRINT(STATUS, FUNC)                                              \
  if (!(STATUS)) {                                                             \
    printf("FAIL " #FUNC "\n");                                                \
    err += 1;                                                                  \
  } else if (VERBOSE) {                                                        \
    printf("PASS " #FUNC "\n");                                                \
  }

#define CHECK_REDUCE_S32(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_ivec("Opand1", v1.s32);                                            \
      print_s32("Scalar", result);                                             \
      print_s32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_REDUCE_U32(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_uvec("Opand1", v1.u32);                                            \
      print_u32("Scalar", result);                                             \
      print_u32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_S32(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_ivec("Opand1", v1.s32);                                            \
      PRINT_MASK(16, 5, "  Mask", mask);                                       \
      print_s32("Scalar", result);                                             \
      print_s32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_U32(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_uvec("Opand1", v1.u32);                                            \
      PRINT_MASK(16, 5, "  Mask", mask);                                       \
      print_u32("Scalar", result);                                             \
      print_u32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_REDUCE_F32(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_fvec("Opand1", v1.f32);                                            \
      print_f32("Scalar", result);                                             \
      print_f32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_F32(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_fvec("Opand1", v1.f32);                                            \
      PRINT_MASK(16, 9, "  Mask", mask);                                       \
      print_f32("Scalar", result);                                             \
      print_f32("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_REDUCE_F64(FUNC)                                                 \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_dvec("Opand1", v1.f64);                                            \
      print_f64("Scalar", result);                                             \
      print_f64("Vector", mresult);                                            \
    }                                                                          \
  }

#define CHECK_MASK_REDUCE_F64(FUNC)                                            \
  {                                                                            \
    int passed = (result == mresult);                                          \
    CHECK_PRINT(passed, FUNC);                                                 \
    if (!passed || SHOW_OP) {                                                  \
      print_dvec("Opand1", v1.f64);                                            \
      PRINT_MASK(8, 10, "  Mask", mask);                                       \
      print_f64("Scalar", result);                                             \
      print_f64("Vector", mresult);                                            \
    }                                                                          \
  }

#define DOONE_REDUCE_S32(OP, FUNC)                                             \
  {                                                                            \
    int result;                                                                \
    int mresult;                                                               \
    result = mask_s32_reduce_op(OP, mask_true, v1.s32);                        \
    mresult = FUNC(v1.zmmi);                                                   \
    CHECK_REDUCE_S32(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_S32(OP, mask, FUNC)                                  \
  {                                                                            \
    int result;                                                                \
    int mresult;                                                               \
    result = mask_s32_reduce_op(OP, mask, v1.s32);                             \
    mresult = FUNC(mask, v1.zmmi);                                             \
    CHECK_MASK_REDUCE_S32(FUNC);                                               \
  }

#define DOONE_REDUCE_U32(OP, FUNC)                                             \
  {                                                                            \
    u32 result;                                                                \
    u32 mresult;                                                               \
    result = mask_u32_reduce_op(OP, mask_true, v1.u32);                        \
    mresult = FUNC(v1.zmmi);                                                   \
    CHECK_REDUCE_U32(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_U32(OP, mask, FUNC)                                  \
  {                                                                            \
    int result;                                                                \
    int mresult;                                                               \
    result = mask_u32_reduce_op(OP, mask, v1.u32);                             \
    mresult = FUNC(mask, v1.zmmi);                                             \
    CHECK_MASK_REDUCE_U32(FUNC);                                               \
  }

#define DOONE_REDUCE_F32(OP, FUNC)                                             \
  {                                                                            \
    float result;                                                              \
    float mresult;                                                             \
    result = mask_f32_reduce_op(OP, mask_true, v1.f32);                        \
    mresult = FUNC(v1.zmm);                                                    \
    CHECK_REDUCE_F32(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_F32(OP, mask, FUNC)                                  \
  {                                                                            \
    float result;                                                              \
    float mresult;                                                             \
    result = mask_f32_reduce_op(OP, mask, v1.f32);                             \
    mresult = FUNC(mask, v1.zmm);                                              \
    CHECK_MASK_REDUCE_F32(FUNC);                                               \
  }

#define DOONE_REDUCE_F64(OP, FUNC)                                             \
  {                                                                            \
    double result;                                                             \
    double mresult;                                                            \
    result = mask_f64_reduce_op(OP, mask_true, v1.f64);                        \
    mresult = FUNC(v1.zmmd);                                                   \
    CHECK_REDUCE_F64(FUNC);                                                    \
  }

#define DOONE_MASK_REDUCE_F64(OP, mask, FUNC)                                  \
  {                                                                            \
    double result;                                                             \
    double mresult;                                                            \
    memset(&result, 0, sizeof(result));                                        \
    memset(&mresult, 0, sizeof(mresult));                                      \
    result = mask_f64_reduce_op(OP, mask, v1.f64);                             \
    mresult = FUNC(mask, v1.zmmd);                                             \
    CHECK_MASK_REDUCE_F64(FUNC);                                               \
  }

__mmask16 mvals[] = {0, 0x82a5};

int main(int argc, char *argv[]) {
  int i;
  int err = 0;
  int init1[16] = {7, 1, -3, 3, 1, 1, 2, 3, 1, 3, 2, 3, -5, 1, 11, 3};

  float finit1[16] = {-1.0, -2.0, 3.0,  4.0,   5.0,  6.0,  7.0,  18.0,
                      -9.0, 10.0, 11.0, -12.0, 13.0, 14.0, 15.0, 16.0};

  double dinit1[8] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
  double dinit2[8] = {0.5, 2.0, 3.0, 2.1, 5.0, 5.2, 7.1, 3.1};

  V512 v1;
  __mmask16 mask = 0x82a5;

  verbose = argc;

  /* zmmi/s32 tests ---------------------------------------- */
  /* _mm512_reduce_add_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_ADD, _mm512_reduce_add_epi32);

  /* _mm512_reduce_mul_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_MUL, _mm512_reduce_mul_epi32);

  /* _mm512_reduce_min_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_MIN, _mm512_reduce_min_epi32);

  /* _mm512_reduce_max_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_MAX, _mm512_reduce_max_epi32);

  /* _mm512_reduce_and_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_AND, _mm512_reduce_and_epi32);

  /* _mm512_reduce_or_epi32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_S32(REDUCE_OR, _mm512_reduce_or_epi32);

  /* _mm512_reduce_min_epu32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_U32(REDUCE_MIN, _mm512_reduce_min_epu32);

  /* _mm512_reduce_max_epu32 */
  init_s32(v1.s32, init1);
  DOONE_REDUCE_U32(REDUCE_MAX, _mm512_reduce_max_epu32);

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_mask_reduce_min_epu32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_U32(REDUCE_MIN, mask, _mm512_mask_reduce_min_epu32);

    /* _mm512_mask_reduce_max_epu32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_U32(REDUCE_MAX, mask, _mm512_mask_reduce_max_epu32);
  }

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_mask_reduce_add_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_ADD, mask, _mm512_mask_reduce_add_epi32);

    /* _mm512_mask_reduce_mul_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_MUL, mask, _mm512_mask_reduce_mul_epi32);

    /* _mm512_mask_reduce_min_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_MIN, mask, _mm512_mask_reduce_min_epi32);

    /* _mm512_mask_reduce_max_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_MAX, mask, _mm512_mask_reduce_max_epi32);

    /* _mm512_mask_reduce_and_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_AND, mask, _mm512_mask_reduce_and_epi32);

    /* _mm512_mask_reduce_or_epi32 */
    init_s32(v1.s32, init1);
    DOONE_MASK_REDUCE_S32(REDUCE_OR, mask, _mm512_mask_reduce_or_epi32);
  }

  /* zmm/f32 tests ---------------------------------------- */
  /* _mm512_reduce_add_ps */
  init_f32(v1.f32, finit1);
  DOONE_REDUCE_F32(REDUCE_ADD, _mm512_reduce_add_ps);

  /* _mm512_reduce_mul_ps */
  init_f32(v1.f32, finit1);
  DOONE_REDUCE_F32(REDUCE_MUL, _mm512_reduce_mul_ps);

  /* _mm512_reduce_gmin_ps */
  init_f32(v1.f32, finit1);
  DOONE_REDUCE_F32(REDUCE_GMIN, _mm512_reduce_min_ps);

  /* _mm512_reduce_gmax_ps */
  init_f32(v1.f32, finit1);
  DOONE_REDUCE_F32(REDUCE_GMAX, _mm512_reduce_max_ps);

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_reduce_gmax_ps */
    init_f32(v1.f32, finit1);
    DOONE_MASK_REDUCE_F32(REDUCE_GMIN, mask, _mm512_mask_reduce_min_ps);

    /* _mm512_reduce_gmax_ps */
    init_f32(v1.f32, finit1);
    DOONE_MASK_REDUCE_F32(REDUCE_GMAX, mask, _mm512_mask_reduce_max_ps);

    /* _mm512_reduce_mul_ps */
    init_f32(v1.f32, finit1);
    DOONE_MASK_REDUCE_F32(REDUCE_MUL, mask, _mm512_mask_reduce_mul_ps);

    /* _mm512_reduce_add_ps */
    init_f32(v1.f32, finit1);
    DOONE_MASK_REDUCE_F32(REDUCE_ADD, mask, _mm512_mask_reduce_add_ps);
  }

  /* zmmd/f64 tests ---------------------------------------- */
  /* _mm512_reduce_add_pd */
  init_f64(v1.f64, dinit1);
  DOONE_REDUCE_F64(REDUCE_ADD, _mm512_reduce_add_pd);

  /* _mm512_reduce_mul_pd */
  init_f64(v1.f64, dinit1);
  DOONE_REDUCE_F64(REDUCE_MUL, _mm512_reduce_mul_pd);

  /* _mm512_reduce_gmin_pd */
  init_f64(v1.f64, dinit1);
  DOONE_REDUCE_F64(REDUCE_GMIN, _mm512_reduce_min_pd);

  /* _mm512_reduce_gmax_pd */
  init_f64(v1.f64, dinit1);
  DOONE_REDUCE_F64(REDUCE_GMAX, _mm512_reduce_max_pd);

  for (i = 0; i < 2; i += 1) {
    mask = mvals[i];
    /* _mm512_mask_reduce_gmin_ps */
    init_f64(v1.f64, dinit1);
    DOONE_MASK_REDUCE_F64(REDUCE_GMIN, mask, _mm512_mask_reduce_min_pd);

    /* _mm512_mask_reduce_gmax_ps */
    init_f64(v1.f64, dinit2);
    DOONE_MASK_REDUCE_F64(REDUCE_GMAX, mask, _mm512_mask_reduce_max_pd);

    /* _mm512_mask_reduce_mul_ps */
    init_f64(v1.f64, dinit1);
    DOONE_MASK_REDUCE_F64(REDUCE_MUL, mask, _mm512_mask_reduce_mul_pd);

    /* _mm512_mask_reduce_add_ps */
    init_f64(v1.f64, dinit2);
    DOONE_MASK_REDUCE_F64(REDUCE_ADD, mask, _mm512_mask_reduce_add_pd);
  }

  if (err) {
    printf("FAILED\n");
    return 1;
  }

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