xref: /external/valgrind/main/none/tests/amd64/fma.c

#include <stdio.h>
#include <string.h>

#define N 64
struct float_test {
   float x[N], y[N], z[N], expected[N], res[N];
} ft __attribute__((aligned (32)));

struct double_test {
   double x[N], y[N], z[N], expected[N], res[N];
} dt __attribute__((aligned (32)));

float plus_zero, plus_infty, minus_infty, nan_value;

static int testf( float x, float y )
{
   unsigned int a, b;
   memcpy( &a, &x, sizeof (a) );
   memcpy( &b, &y, sizeof (b) );
   if ((a & 0x7fc00000U) == 0x7fc00000U)
      return (b & 0x7fc00000U) != 0x7fc00000U;
   return memcmp( &a, &b, sizeof (a) ) != 0;
}

static int test_fmaf( void )
{
   int res = 0, i, j;
   float w;
   for (i = 0; i < N; i++) {
      int thisres = 0;
      __asm __volatile__ ("vfmadd132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmadd132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "m" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmadd213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmadd213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "m" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmadd231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "x" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmadd231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "m" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      if (thisres)
         printf( "Failure 1 %d %a %a\n", i, w, ft.expected[i] );
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vfnmsub132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmsub132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "m" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmsub213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmsub213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "m" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmsub231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "x" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmsub231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "m" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      if (thisres)
         printf( "Failure 2 %d %a %a\n", i, w, ft.expected[i] );
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i++) {
      int thisres = 0;
      __asm __volatile__ ("vfmsub132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmsub132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "m" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmsub213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmsub213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "m" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmsub231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "x" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      __asm __volatile__ ("vfmsub231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "m" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( w, ft.expected[i] );
      if (thisres)
         printf( "Failure 3 %d %a %a\n", i, w, ft.expected[i] );
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vfnmadd132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmadd132ss %2, %3, %0" : "=x" (w) : "0" (ft.x[i]), "m" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmadd213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "x" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmadd213ss %3, %2, %0" : "=x" (w) : "0" (ft.x[i]), "x" (ft.y[i]), "m" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmadd231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "x" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      __asm __volatile__ ("vfnmadd231ss %2, %1, %0" : "=x" (w) : "x" (ft.x[i]), "m" (ft.y[i]), "0" (ft.z[i]));
      thisres |= testf( -w, ft.expected[i] );
      if (thisres)
         printf( "Failure 4 %d %a %a\n", i, w, ft.expected[i] );
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfmadd132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfmadd132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfmadd213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfmadd213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfmadd231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfmadd231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 5 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfnmsub132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfnmsub132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfnmsub213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfnmsub213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfnmsub231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfnmsub231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 6 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfmsub132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfmsub132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfmsub213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfmsub213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfmsub231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfmsub231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 7 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfnmadd132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfnmadd132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfnmadd213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfnmadd213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfnmadd231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfnmadd231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 8 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfmaddsub132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfmaddsub132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfmaddsub213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfmaddsub213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfmaddsub231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfmaddsub231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 9 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%3), %%xmm8;"
                          "vfmsubadd132ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm8;"
                          "vfmsubadd132ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%3), %%xmm7; vmovaps (%2), %%xmm8;"
                          "vfmsubadd213ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%xmm9; vmovaps (%2), %%xmm8;"
                          "vfmsubadd213ps (%3), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%2), %%xmm7; vmovaps (%1), %%xmm8;"
                          "vfmsubadd231ps %%xmm7, %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%xmm9; vmovaps (%1), %%xmm8;"
                          "vfmsubadd231ps (%2), %%xmm8, %%xmm9;"
                          "vmovaps %%xmm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 10 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 8) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfmadd132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfmadd132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfmadd213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfmadd213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfmadd231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfmadd231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 11 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfnmsub132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfnmsub132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfnmsub213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfnmsub213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfnmsub231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfnmsub231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 12 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 8) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfmsub132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfmsub132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfmsub213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfmsub213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfmsub231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfmsub231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 13 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfnmadd132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfnmadd132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfnmadd213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfnmadd213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfnmadd231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfnmadd231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( -ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 14 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 8) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfmaddsub132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfmaddsub132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfmaddsub213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfmaddsub213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfmaddsub231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfmaddsub231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 15 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      ft.z[i] = -ft.z[i];
   for (i = 0; i < N; i += 8) {
      int thisres = 0;
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%3), %%ymm8;"
                          "vfmsubadd132ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm8;"
                          "vfmsubadd132ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%3), %%ymm7; vmovaps (%2), %%ymm8;"
                          "vfmsubadd213ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%1), %%ymm9; vmovaps (%2), %%ymm8;"
                          "vfmsubadd213ps (%3), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%2), %%ymm7; vmovaps (%1), %%ymm8;"
                          "vfmsubadd231ps %%ymm7, %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      __asm __volatile__ ("vmovaps (%3), %%ymm9; vmovaps (%1), %%ymm8;"
                          "vfmsubadd231ps (%2), %%ymm8, %%ymm9;"
                          "vmovaps %%ymm9, (%0)" : : "r" (&ft.res[i]), "r" (&ft.x[i]),
                                                     "r" (&ft.y[i]), "r" (&ft.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 8; j++)
         thisres |= testf( ft.res[i+j], ft.expected[i+j] );
      if (thisres) {
         printf( "Failure 16 %d", i );
         for (j = 0; j < 8; j++)
            printf( " %a %a", ft.res[i+j], ft.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      ft.z[i] = -ft.z[i];
   return res;
}

static int test( double x, double y )
{
   unsigned long long a, b;
   memcpy( &a, &x, sizeof (a) );
   memcpy( &b, &y, sizeof (b) );
   if ((a & 0x7ff8000000000000ULL) == 0x7ff8000000000000ULL)
      return (b & 0x7ff8000000000000ULL) != 0x7ff8000000000000ULL;
   return memcmp( &a, &b, sizeof (a) ) != 0;
}

static int test_fma( void )
{
   int res = 0, i, j;
   double w;
   for (i = 0; i < N; i++) {
      int thisres = 0;
      __asm __volatile__ ("vfmadd132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmadd132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "m" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmadd213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmadd213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "m" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmadd231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "x" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmadd231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "m" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      if (thisres)
         printf( "Failure 1 %d %a %a\n", i, w, dt.expected[i] );
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vfnmsub132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmsub132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "m" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmsub213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmsub213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "m" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmsub231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "x" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmsub231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "m" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      if (thisres)
         printf( "Failure 2 %d %a %a\n", i, w, dt.expected[i] );
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i++) {
      int thisres = 0;
      __asm __volatile__ ("vfmsub132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmsub132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "m" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmsub213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmsub213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "m" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmsub231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "x" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      __asm __volatile__ ("vfmsub231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "m" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( w, dt.expected[i] );
      if (thisres)
         printf( "Failure 3 %d %a %a\n", i, w, dt.expected[i] );
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vfnmadd132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmadd132sd %2, %3, %0" : "=x" (w) : "0" (dt.x[i]), "m" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmadd213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "x" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmadd213sd %3, %2, %0" : "=x" (w) : "0" (dt.x[i]), "x" (dt.y[i]), "m" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmadd231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "x" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      __asm __volatile__ ("vfnmadd231sd %2, %1, %0" : "=x" (w) : "x" (dt.x[i]), "m" (dt.y[i]), "0" (dt.z[i]));
      thisres |= test( -w, dt.expected[i] );
      if (thisres)
         printf( "Failure 4 %d %a %a\n", i, w, dt.expected[i] );
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 2) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfmadd132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfmadd132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfmadd213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfmadd213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfmadd231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfmadd231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 5 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfnmsub132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfnmsub132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfnmsub213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfnmsub213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfnmsub231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfnmsub231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 6 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 2) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfmsub132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfmsub132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfmsub213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfmsub213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfmsub231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfmsub231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 7 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfnmadd132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfnmadd132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfnmadd213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfnmadd213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfnmadd231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfnmadd231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 8 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 2) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfmaddsub132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfmaddsub132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfmaddsub213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfmaddsub213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfmaddsub231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfmaddsub231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 9 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 2) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%3), %%xmm8;"
                          "vfmsubadd132pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm8;"
                          "vfmsubadd132pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%3), %%xmm7; vmovapd (%2), %%xmm8;"
                          "vfmsubadd213pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%xmm9; vmovapd (%2), %%xmm8;"
                          "vfmsubadd213pd (%3), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%2), %%xmm7; vmovapd (%1), %%xmm8;"
                          "vfmsubadd231pd %%xmm7, %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%xmm9; vmovapd (%1), %%xmm8;"
                          "vfmsubadd231pd (%2), %%xmm8, %%xmm9;"
                          "vmovapd %%xmm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 2; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 10 %d", i );
         for (j = 0; j < 2; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfmadd132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfmadd132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfmadd213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfmadd213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfmadd231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfmadd231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 11 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfnmsub132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfnmsub132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfnmsub213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfnmsub213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfnmsub231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfnmsub231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 12 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfmsub132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfmsub132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfmsub213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfmsub213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfmsub231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfmsub231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 13 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
      thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfnmadd132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfnmadd132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfnmadd213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfnmadd213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfnmadd231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfnmadd231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( -dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 14 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfmaddsub132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfmaddsub132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfmaddsub213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfmaddsub213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfmaddsub231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfmaddsub231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 15 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 0; i < N; i++)
      dt.z[i] = -dt.z[i];
   for (i = 0; i < N; i += 4) {
      int thisres = 0;
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%3), %%ymm8;"
                          "vfmsubadd132pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm8;"
                          "vfmsubadd132pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%3), %%ymm7; vmovapd (%2), %%ymm8;"
                          "vfmsubadd213pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%1), %%ymm9; vmovapd (%2), %%ymm8;"
                          "vfmsubadd213pd (%3), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%2), %%ymm7; vmovapd (%1), %%ymm8;"
                          "vfmsubadd231pd %%ymm7, %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      __asm __volatile__ ("vmovapd (%3), %%ymm9; vmovapd (%1), %%ymm8;"
                          "vfmsubadd231pd (%2), %%ymm8, %%ymm9;"
                          "vmovapd %%ymm9, (%0)" : : "r" (&dt.res[i]), "r" (&dt.x[i]),
                                                     "r" (&dt.y[i]), "r" (&dt.z[i]) : "xmm7", "xmm8", "xmm9");
      for (j = 0; j < 4; j++)
         thisres |= test( dt.res[i+j], dt.expected[i+j] );
      if (thisres) {
         printf( "Failure 16 %d", i );
         for (j = 0; j < 4; j++)
            printf( " %a %a", dt.res[i+j], dt.expected[i+j] );
         printf( "\n" );
      }
      res |= thisres;
   }
   for (i = 1; i < N; i += 2)
      dt.z[i] = -dt.z[i];
   return res;
}

int main( )
{
   int res = 0;
   int i = 0;
   plus_zero = 0.0;
   __asm __volatile__ ("" : : "r" (&plus_zero) : "memory");
   nan_value = plus_zero / plus_zero;
   plus_infty = 3.40282346638528859812e+38F * 16.0F;
   minus_infty = -plus_infty;
#define TEST_F( a, b, c, d ) \
   do {				\
      ft.x[i] = a;		\
      ft.y[i] = b;		\
      ft.z[i] = c;		\
      ft.expected[i] = d;	\
      i++;			\
   } while (0)
   TEST_F( 1.0, 2.0, 3.0, 5.0 );
   TEST_F( nan_value, 2.0, 3.0, nan_value );
   TEST_F( 1.0, nan_value, 3.0, nan_value );
   TEST_F( 1.0, 2.0, nan_value, nan_value );
   TEST_F( plus_infty, 0.0, nan_value, nan_value );
   TEST_F( minus_infty, 0.0, nan_value, nan_value );
   TEST_F( 0.0, plus_infty, nan_value, nan_value );
   TEST_F( 0.0, minus_infty, nan_value, nan_value );
   TEST_F( plus_infty, 0.0, 1.0, nan_value );
   TEST_F( minus_infty, 0.0, 1.0, nan_value );
   TEST_F( 0.0, plus_infty, 1.0, nan_value );
   TEST_F( 0.0, minus_infty, 1.0, nan_value );
   TEST_F( plus_infty, plus_infty, minus_infty, nan_value );
   TEST_F( minus_infty, plus_infty, plus_infty, nan_value );
   TEST_F( plus_infty, minus_infty, plus_infty, nan_value );
   TEST_F( minus_infty, minus_infty, minus_infty, nan_value );
   TEST_F( plus_infty, 3.5L, minus_infty, nan_value );
   TEST_F( minus_infty, -7.5L, minus_infty, nan_value );
   TEST_F( -13.5L, plus_infty, plus_infty, nan_value );
   TEST_F( minus_infty, 7.5L, plus_infty, nan_value );
   TEST_F( 1.25L, 0.75L, 0.0625L, 1.0L );
   TEST_F( -3.40282346638528859812e+38F, -3.40282346638528859812e+38F, minus_infty, minus_infty );
   TEST_F( 3.40282346638528859812e+38F / 2, 3.40282346638528859812e+38F / 2, minus_infty, minus_infty );
   TEST_F( -3.40282346638528859812e+38F, 3.40282346638528859812e+38F, plus_infty, plus_infty );
   TEST_F( 3.40282346638528859812e+38F / 2, -3.40282346638528859812e+38F / 4, plus_infty, plus_infty );
   TEST_F( plus_infty, 4, plus_infty, plus_infty );
   TEST_F( 2, minus_infty, minus_infty, minus_infty );
   TEST_F( minus_infty, minus_infty, plus_infty, plus_infty );
   TEST_F( plus_infty, minus_infty, minus_infty, minus_infty );
   TEST_F( 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13 );
   TEST_F( 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20 );
   TEST_F( 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25 );
   TEST_F( 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52 );
   TEST_F( 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115 );
   TEST_F( -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127 );
   TEST_F( 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127 );

   res |= test_fmaf( );
   i = 0;
#define TEST( a, b, c, d ) \
   do {				\
      dt.x[i] = a;		\
      dt.y[i] = b;		\
      dt.z[i] = c;		\
      dt.expected[i] = d;	\
      i++;			\
   } while (0)
   TEST( 1.0, 2.0, 3.0, 5.0 );
   TEST( nan_value, 2.0, 3.0, nan_value );
   TEST( 1.0, nan_value, 3.0, nan_value );
   TEST( 1.0, 2.0, nan_value, nan_value );
   TEST( plus_infty, 0.0, nan_value, nan_value );
   TEST( minus_infty, 0.0, nan_value, nan_value );
   TEST( 0.0, plus_infty, nan_value, nan_value );
   TEST( 0.0, minus_infty, nan_value, nan_value );
   TEST( plus_infty, 0.0, 1.0, nan_value );
   TEST( minus_infty, 0.0, 1.0, nan_value );
   TEST( 0.0, plus_infty, 1.0, nan_value );
   TEST( 0.0, minus_infty, 1.0, nan_value );
   TEST( plus_infty, plus_infty, minus_infty, nan_value );
   TEST( minus_infty, plus_infty, plus_infty, nan_value );
   TEST( plus_infty, minus_infty, plus_infty, nan_value );
   TEST( minus_infty, minus_infty, minus_infty, nan_value );
   TEST( plus_infty, 3.5L, minus_infty, nan_value );
   TEST( minus_infty, -7.5L, minus_infty, nan_value );
   TEST( -13.5L, plus_infty, plus_infty, nan_value );
   TEST( minus_infty, 7.5L, plus_infty, nan_value );
   TEST( 1.25L, 0.75L, 0.0625L, 1.0L );
   TEST( -1.79769313486231570815e+308L, -1.79769313486231570815e+308L, minus_infty, minus_infty );
   TEST( 1.79769313486231570815e+308L / 2, 1.79769313486231570815e+308L / 2, minus_infty, minus_infty );
   TEST( -1.79769313486231570815e+308L, 1.79769313486231570815e+308L, plus_infty, plus_infty );
   TEST( 1.79769313486231570815e+308L / 2, -1.79769313486231570815e+308L / 4, plus_infty, plus_infty );
   TEST( plus_infty, 4, plus_infty, plus_infty );
   TEST( 2, minus_infty, minus_infty, minus_infty );
   TEST( minus_infty, minus_infty, plus_infty, plus_infty );
   TEST( plus_infty, minus_infty, minus_infty, minus_infty );
   TEST( 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13 );
   TEST( 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52 );
   TEST( 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0 );
   TEST( 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1 );
   TEST( 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53 );
   TEST( 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176 );
   TEST( 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011 );
   TEST( -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023 );
   TEST( 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023 );
   TEST( 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0 );
   TEST( 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022 );
   TEST( 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022 );
   TEST( 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022 );
   TEST( 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022 );
   TEST( 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022 );
   TEST( 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022 );
   TEST( -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022 );
   TEST( -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022 );
   TEST( 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022 );
   TEST( -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983 );

   res |= test_fma( );
   if (res == 0)
      printf( "Testing successful\n");
   return 0;
}