#include <math.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

typedef union {
  char sb[1];
  unsigned char ub[1];
} reg8_t;

typedef union {
  char sb[2];
  unsigned char ub[2];
  short sw[1];
  unsigned short uw[1];
} reg16_t;

typedef union {
  char sb[4];
  unsigned char ub[4];
  short sw[2];
  unsigned short uw[2];
  long int sd[1];
  unsigned long int ud[1];
  float ps[1];
} reg32_t;

typedef union {
  char sb[8];
  unsigned char ub[8];
  short sw[4];
  unsigned short uw[4];
  long int sd[2];
  unsigned long int ud[2];
  long long int sq[1];
  unsigned long long int uq[1];
  float ps[2];
  double pd[1];
} reg64_t __attribute__ ((aligned (8)));

typedef union {
  char sb[16];
  unsigned char ub[16];
  short sw[8];
  unsigned short uw[8];
  long int sd[4];
  unsigned long int ud[4];
  long long int sq[2];
  unsigned long long int uq[2];
  float ps[4];
  double pd[2];
} reg128_t __attribute__ ((aligned (16)));

static sigjmp_buf catchpoint;

static void handle_sigill(int signum)
{
   siglongjmp(catchpoint, 1);
}

__attribute__((unused))
static int eq_float(float f1, float f2)
{
   return f1 == f2 || fabsf(f1 - f2) < fabsf(f1) * 1.5 * pow(2,-12);
}

__attribute__((unused))
static int eq_double(double d1, double d2)
{
   return d1 == d2 || fabs(d1 - d2) < fabs(d1) * 1.5 * pow(2,-12);
}

static void cmova_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmova %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmova_1 ... ok\n");
      }
      else
      {
         printf("cmova_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmova_1 ... failed\n");
   }

   return;
}

static void cmova_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmova %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_2 ... ok\n");
      }
      else
      {
         printf("cmova_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_2 ... failed\n");
   }

   return;
}

static void cmova_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmova %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_3 ... ok\n");
      }
      else
      {
         printf("cmova_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_3 ... failed\n");
   }

   return;
}

static void cmova_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmova %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_4 ... ok\n");
      }
      else
      {
         printf("cmova_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_4 ... failed\n");
   }

   return;
}

static void cmova_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmova_5 ... ok\n");
      }
      else
      {
         printf("cmova_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmova_5 ... failed\n");
   }

   return;
}

static void cmova_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_6 ... ok\n");
      }
      else
      {
         printf("cmova_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_6 ... failed\n");
   }

   return;
}

static void cmova_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_7 ... ok\n");
      }
      else
      {
         printf("cmova_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_7 ... failed\n");
   }

   return;
}

static void cmova_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmova_8 ... ok\n");
      }
      else
      {
         printf("cmova_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmova_8 ... failed\n");
   }

   return;
}

static void cmovae_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovae %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovae_1 ... ok\n");
      }
      else
      {
         printf("cmovae_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovae_1 ... failed\n");
   }

   return;
}

static void cmovae_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovae %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovae_2 ... ok\n");
      }
      else
      {
         printf("cmovae_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovae_2 ... failed\n");
   }

   return;
}

static void cmovae_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovae %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovae_3 ... ok\n");
      }
      else
      {
         printf("cmovae_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovae_3 ... failed\n");
   }

   return;
}

static void cmovae_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovae %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovae_4 ... ok\n");
      }
      else
      {
         printf("cmovae_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovae_4 ... failed\n");
   }

   return;
}

static void cmovb_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovb %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovb_1 ... ok\n");
      }
      else
      {
         printf("cmovb_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovb_1 ... failed\n");
   }

   return;
}

static void cmovb_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovb %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovb_2 ... ok\n");
      }
      else
      {
         printf("cmovb_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovb_2 ... failed\n");
   }

   return;
}

static void cmovb_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovb %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovb_3 ... ok\n");
      }
      else
      {
         printf("cmovb_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovb_3 ... failed\n");
   }

   return;
}

static void cmovb_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovb %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovb_4 ... ok\n");
      }
      else
      {
         printf("cmovb_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovb_4 ... failed\n");
   }

   return;
}

static void cmovbe_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovbe_1 ... ok\n");
      }
      else
      {
         printf("cmovbe_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovbe_1 ... failed\n");
   }

   return;
}

static void cmovbe_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_2 ... ok\n");
      }
      else
      {
         printf("cmovbe_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_2 ... failed\n");
   }

   return;
}

static void cmovbe_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_3 ... ok\n");
      }
      else
      {
         printf("cmovbe_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_3 ... failed\n");
   }

   return;
}

static void cmovbe_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_4 ... ok\n");
      }
      else
      {
         printf("cmovbe_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_4 ... failed\n");
   }

   return;
}

static void cmovbe_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovbe_5 ... ok\n");
      }
      else
      {
         printf("cmovbe_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovbe_5 ... failed\n");
   }

   return;
}

static void cmovbe_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_6 ... ok\n");
      }
      else
      {
         printf("cmovbe_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_6 ... failed\n");
   }

   return;
}

static void cmovbe_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_7 ... ok\n");
      }
      else
      {
         printf("cmovbe_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_7 ... failed\n");
   }

   return;
}

static void cmovbe_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovbe_8 ... ok\n");
      }
      else
      {
         printf("cmovbe_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovbe_8 ... failed\n");
   }

   return;
}

static void cmovc_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovc %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovc_1 ... ok\n");
      }
      else
      {
         printf("cmovc_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovc_1 ... failed\n");
   }

   return;
}

static void cmovc_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovc %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovc_2 ... ok\n");
      }
      else
      {
         printf("cmovc_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovc_2 ... failed\n");
   }

   return;
}

static void cmovc_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovc %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovc_3 ... ok\n");
      }
      else
      {
         printf("cmovc_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovc_3 ... failed\n");
   }

   return;
}

static void cmovc_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovc %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovc_4 ... ok\n");
      }
      else
      {
         printf("cmovc_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovc_4 ... failed\n");
   }

   return;
}

static void cmove_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmove %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmove_1 ... ok\n");
      }
      else
      {
         printf("cmove_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmove_1 ... failed\n");
   }

   return;
}

static void cmove_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmove %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmove_2 ... ok\n");
      }
      else
      {
         printf("cmove_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmove_2 ... failed\n");
   }

   return;
}

static void cmove_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmove %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmove_3 ... ok\n");
      }
      else
      {
         printf("cmove_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmove_3 ... failed\n");
   }

   return;
}

static void cmove_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmove %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmove_4 ... ok\n");
      }
      else
      {
         printf("cmove_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmove_4 ... failed\n");
   }

   return;
}

static void cmovg_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovg_1 ... ok\n");
      }
      else
      {
         printf("cmovg_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovg_1 ... failed\n");
   }

   return;
}

static void cmovg_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_2 ... ok\n");
      }
      else
      {
         printf("cmovg_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_2 ... failed\n");
   }

   return;
}

static void cmovg_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_3 ... ok\n");
      }
      else
      {
         printf("cmovg_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_3 ... failed\n");
   }

   return;
}

static void cmovg_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_4 ... ok\n");
      }
      else
      {
         printf("cmovg_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_4 ... failed\n");
   }

   return;
}

static void cmovg_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_5 ... ok\n");
      }
      else
      {
         printf("cmovg_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_5 ... failed\n");
   }

   return;
}

static void cmovg_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_6 ... ok\n");
      }
      else
      {
         printf("cmovg_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_6 ... failed\n");
   }

   return;
}

static void cmovg_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovg_7 ... ok\n");
      }
      else
      {
         printf("cmovg_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovg_7 ... failed\n");
   }

   return;
}

static void cmovg_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovg %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_8 ... ok\n");
      }
      else
      {
         printf("cmovg_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_8 ... failed\n");
   }

   return;
}

static void cmovg_9(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovg_9 ... ok\n");
      }
      else
      {
         printf("cmovg_9 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovg_9 ... failed\n");
   }

   return;
}

static void cmovg_10(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_10 ... ok\n");
      }
      else
      {
         printf("cmovg_10 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_10 ... failed\n");
   }

   return;
}

static void cmovg_11(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_11 ... ok\n");
      }
      else
      {
         printf("cmovg_11 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_11 ... failed\n");
   }

   return;
}

static void cmovg_12(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_12 ... ok\n");
      }
      else
      {
         printf("cmovg_12 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_12 ... failed\n");
   }

   return;
}

static void cmovg_13(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_13 ... ok\n");
      }
      else
      {
         printf("cmovg_13 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_13 ... failed\n");
   }

   return;
}

static void cmovg_14(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_14 ... ok\n");
      }
      else
      {
         printf("cmovg_14 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_14 ... failed\n");
   }

   return;
}

static void cmovg_15(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovg_15 ... ok\n");
      }
      else
      {
         printf("cmovg_15 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovg_15 ... failed\n");
   }

   return;
}

static void cmovg_16(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovg_16 ... ok\n");
      }
      else
      {
         printf("cmovg_16 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovg_16 ... failed\n");
   }

   return;
}

static void cmovge_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovge_1 ... ok\n");
      }
      else
      {
         printf("cmovge_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovge_1 ... failed\n");
   }

   return;
}

static void cmovge_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovge_2 ... ok\n");
      }
      else
      {
         printf("cmovge_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovge_2 ... failed\n");
   }

   return;
}

static void cmovge_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovge_3 ... ok\n");
      }
      else
      {
         printf("cmovge_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovge_3 ... failed\n");
   }

   return;
}

static void cmovge_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovge_4 ... ok\n");
      }
      else
      {
         printf("cmovge_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovge_4 ... failed\n");
   }

   return;
}

static void cmovge_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovge_5 ... ok\n");
      }
      else
      {
         printf("cmovge_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovge_5 ... failed\n");
   }

   return;
}

static void cmovge_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovge_6 ... ok\n");
      }
      else
      {
         printf("cmovge_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovge_6 ... failed\n");
   }

   return;
}

static void cmovge_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovge_7 ... ok\n");
      }
      else
      {
         printf("cmovge_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovge_7 ... failed\n");
   }

   return;
}

static void cmovge_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovge_8 ... ok\n");
      }
      else
      {
         printf("cmovge_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovge_8 ... failed\n");
   }

   return;
}

static void cmovl_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovl_1 ... ok\n");
      }
      else
      {
         printf("cmovl_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovl_1 ... failed\n");
   }

   return;
}

static void cmovl_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovl_2 ... ok\n");
      }
      else
      {
         printf("cmovl_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovl_2 ... failed\n");
   }

   return;
}

static void cmovl_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovl_3 ... ok\n");
      }
      else
      {
         printf("cmovl_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovl_3 ... failed\n");
   }

   return;
}

static void cmovl_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovl_4 ... ok\n");
      }
      else
      {
         printf("cmovl_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovl_4 ... failed\n");
   }

   return;
}

static void cmovl_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovl_5 ... ok\n");
      }
      else
      {
         printf("cmovl_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovl_5 ... failed\n");
   }

   return;
}

static void cmovl_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovl_6 ... ok\n");
      }
      else
      {
         printf("cmovl_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovl_6 ... failed\n");
   }

   return;
}

static void cmovl_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovl_7 ... ok\n");
      }
      else
      {
         printf("cmovl_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovl_7 ... failed\n");
   }

   return;
}

static void cmovl_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovl_8 ... ok\n");
      }
      else
      {
         printf("cmovl_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovl_8 ... failed\n");
   }

   return;
}

static void cmovle_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovle_1 ... ok\n");
      }
      else
      {
         printf("cmovle_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovle_1 ... failed\n");
   }

   return;
}

static void cmovle_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_2 ... ok\n");
      }
      else
      {
         printf("cmovle_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_2 ... failed\n");
   }

   return;
}

static void cmovle_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_3 ... ok\n");
      }
      else
      {
         printf("cmovle_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_3 ... failed\n");
   }

   return;
}

static void cmovle_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_4 ... ok\n");
      }
      else
      {
         printf("cmovle_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_4 ... failed\n");
   }

   return;
}

static void cmovle_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_5 ... ok\n");
      }
      else
      {
         printf("cmovle_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_5 ... failed\n");
   }

   return;
}

static void cmovle_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_6 ... ok\n");
      }
      else
      {
         printf("cmovle_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_6 ... failed\n");
   }

   return;
}

static void cmovle_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovle_7 ... ok\n");
      }
      else
      {
         printf("cmovle_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovle_7 ... failed\n");
   }

   return;
}

static void cmovle_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_8 ... ok\n");
      }
      else
      {
         printf("cmovle_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_8 ... failed\n");
   }

   return;
}

static void cmovle_9(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovle_9 ... ok\n");
      }
      else
      {
         printf("cmovle_9 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovle_9 ... failed\n");
   }

   return;
}

static void cmovle_10(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_10 ... ok\n");
      }
      else
      {
         printf("cmovle_10 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_10 ... failed\n");
   }

   return;
}

static void cmovle_11(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_11 ... ok\n");
      }
      else
      {
         printf("cmovle_11 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_11 ... failed\n");
   }

   return;
}

static void cmovle_12(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_12 ... ok\n");
      }
      else
      {
         printf("cmovle_12 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_12 ... failed\n");
   }

   return;
}

static void cmovle_13(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_13 ... ok\n");
      }
      else
      {
         printf("cmovle_13 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_13 ... failed\n");
   }

   return;
}

static void cmovle_14(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_14 ... ok\n");
      }
      else
      {
         printf("cmovle_14 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_14 ... failed\n");
   }

   return;
}

static void cmovle_15(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovle_15 ... ok\n");
      }
      else
      {
         printf("cmovle_15 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovle_15 ... failed\n");
   }

   return;
}

static void cmovle_16(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovle_16 ... ok\n");
      }
      else
      {
         printf("cmovle_16 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovle_16 ... failed\n");
   }

   return;
}

static void cmovna_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovna %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovna_1 ... ok\n");
      }
      else
      {
         printf("cmovna_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovna_1 ... failed\n");
   }

   return;
}

static void cmovna_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovna %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_2 ... ok\n");
      }
      else
      {
         printf("cmovna_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_2 ... failed\n");
   }

   return;
}

static void cmovna_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovna %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_3 ... ok\n");
      }
      else
      {
         printf("cmovna_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_3 ... failed\n");
   }

   return;
}

static void cmovna_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovna %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_4 ... ok\n");
      }
      else
      {
         printf("cmovna_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_4 ... failed\n");
   }

   return;
}

static void cmovna_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovna_5 ... ok\n");
      }
      else
      {
         printf("cmovna_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovna_5 ... failed\n");
   }

   return;
}

static void cmovna_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_6 ... ok\n");
      }
      else
      {
         printf("cmovna_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_6 ... failed\n");
   }

   return;
}

static void cmovna_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_7 ... ok\n");
      }
      else
      {
         printf("cmovna_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_7 ... failed\n");
   }

   return;
}

static void cmovna_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovna_8 ... ok\n");
      }
      else
      {
         printf("cmovna_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovna_8 ... failed\n");
   }

   return;
}

static void cmovnae_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnae %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnae_1 ... ok\n");
      }
      else
      {
         printf("cmovnae_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnae_1 ... failed\n");
   }

   return;
}

static void cmovnae_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnae %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnae_2 ... ok\n");
      }
      else
      {
         printf("cmovnae_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnae_2 ... failed\n");
   }

   return;
}

static void cmovnae_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnae %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnae_3 ... ok\n");
      }
      else
      {
         printf("cmovnae_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnae_3 ... failed\n");
   }

   return;
}

static void cmovnae_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnae %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnae_4 ... ok\n");
      }
      else
      {
         printf("cmovnae_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnae_4 ... failed\n");
   }

   return;
}

static void cmovnb_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnb %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnb_1 ... ok\n");
      }
      else
      {
         printf("cmovnb_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnb_1 ... failed\n");
   }

   return;
}

static void cmovnb_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnb %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnb_2 ... ok\n");
      }
      else
      {
         printf("cmovnb_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnb_2 ... failed\n");
   }

   return;
}

static void cmovnb_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnb %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnb_3 ... ok\n");
      }
      else
      {
         printf("cmovnb_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnb_3 ... failed\n");
   }

   return;
}

static void cmovnb_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnb %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnb_4 ... ok\n");
      }
      else
      {
         printf("cmovnb_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnb_4 ... failed\n");
   }

   return;
}

static void cmovnbe_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnbe_1 ... ok\n");
      }
      else
      {
         printf("cmovnbe_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnbe_1 ... failed\n");
   }

   return;
}

static void cmovnbe_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_2 ... ok\n");
      }
      else
      {
         printf("cmovnbe_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_2 ... failed\n");
   }

   return;
}

static void cmovnbe_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_3 ... ok\n");
      }
      else
      {
         printf("cmovnbe_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_3 ... failed\n");
   }

   return;
}

static void cmovnbe_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_4 ... ok\n");
      }
      else
      {
         printf("cmovnbe_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_4 ... failed\n");
   }

   return;
}

static void cmovnbe_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnbe_5 ... ok\n");
      }
      else
      {
         printf("cmovnbe_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnbe_5 ... failed\n");
   }

   return;
}

static void cmovnbe_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_6 ... ok\n");
      }
      else
      {
         printf("cmovnbe_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_6 ... failed\n");
   }

   return;
}

static void cmovnbe_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_7 ... ok\n");
      }
      else
      {
         printf("cmovnbe_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_7 ... failed\n");
   }

   return;
}

static void cmovnbe_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnbe_8 ... ok\n");
      }
      else
      {
         printf("cmovnbe_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnbe_8 ... failed\n");
   }

   return;
}

static void cmovnc_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnc %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnc_1 ... ok\n");
      }
      else
      {
         printf("cmovnc_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnc_1 ... failed\n");
   }

   return;
}

static void cmovnc_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnc %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnc_2 ... ok\n");
      }
      else
      {
         printf("cmovnc_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnc_2 ... failed\n");
   }

   return;
}

static void cmovnc_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnc %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnc_3 ... ok\n");
      }
      else
      {
         printf("cmovnc_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnc_3 ... failed\n");
   }

   return;
}

static void cmovnc_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnc %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnc_4 ... ok\n");
      }
      else
      {
         printf("cmovnc_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnc_4 ... failed\n");
   }

   return;
}

static void cmovne_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovne %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovne_1 ... ok\n");
      }
      else
      {
         printf("cmovne_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovne_1 ... failed\n");
   }

   return;
}

static void cmovne_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovne %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovne_2 ... ok\n");
      }
      else
      {
         printf("cmovne_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovne_2 ... failed\n");
   }

   return;
}

static void cmovne_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovne %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovne_3 ... ok\n");
      }
      else
      {
         printf("cmovne_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovne_3 ... failed\n");
   }

   return;
}

static void cmovne_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovne %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovne_4 ... ok\n");
      }
      else
      {
         printf("cmovne_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovne_4 ... failed\n");
   }

   return;
}

static void cmovng_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovng_1 ... ok\n");
      }
      else
      {
         printf("cmovng_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovng_1 ... failed\n");
   }

   return;
}

static void cmovng_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_2 ... ok\n");
      }
      else
      {
         printf("cmovng_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_2 ... failed\n");
   }

   return;
}

static void cmovng_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_3 ... ok\n");
      }
      else
      {
         printf("cmovng_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_3 ... failed\n");
   }

   return;
}

static void cmovng_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_4 ... ok\n");
      }
      else
      {
         printf("cmovng_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_4 ... failed\n");
   }

   return;
}

static void cmovng_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_5 ... ok\n");
      }
      else
      {
         printf("cmovng_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_5 ... failed\n");
   }

   return;
}

static void cmovng_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_6 ... ok\n");
      }
      else
      {
         printf("cmovng_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_6 ... failed\n");
   }

   return;
}

static void cmovng_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovng_7 ... ok\n");
      }
      else
      {
         printf("cmovng_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovng_7 ... failed\n");
   }

   return;
}

static void cmovng_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovng %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_8 ... ok\n");
      }
      else
      {
         printf("cmovng_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_8 ... failed\n");
   }

   return;
}

static void cmovng_9(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovng_9 ... ok\n");
      }
      else
      {
         printf("cmovng_9 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovng_9 ... failed\n");
   }

   return;
}

static void cmovng_10(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_10 ... ok\n");
      }
      else
      {
         printf("cmovng_10 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_10 ... failed\n");
   }

   return;
}

static void cmovng_11(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_11 ... ok\n");
      }
      else
      {
         printf("cmovng_11 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_11 ... failed\n");
   }

   return;
}

static void cmovng_12(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_12 ... ok\n");
      }
      else
      {
         printf("cmovng_12 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_12 ... failed\n");
   }

   return;
}

static void cmovng_13(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_13 ... ok\n");
      }
      else
      {
         printf("cmovng_13 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_13 ... failed\n");
   }

   return;
}

static void cmovng_14(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_14 ... ok\n");
      }
      else
      {
         printf("cmovng_14 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_14 ... failed\n");
   }

   return;
}

static void cmovng_15(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovng_15 ... ok\n");
      }
      else
      {
         printf("cmovng_15 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovng_15 ... failed\n");
   }

   return;
}

static void cmovng_16(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovng_16 ... ok\n");
      }
      else
      {
         printf("cmovng_16 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovng_16 ... failed\n");
   }

   return;
}

static void cmovnge_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnge_1 ... ok\n");
      }
      else
      {
         printf("cmovnge_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnge_1 ... failed\n");
   }

   return;
}

static void cmovnge_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnge_2 ... ok\n");
      }
      else
      {
         printf("cmovnge_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnge_2 ... failed\n");
   }

   return;
}

static void cmovnge_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnge_3 ... ok\n");
      }
      else
      {
         printf("cmovnge_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnge_3 ... failed\n");
   }

   return;
}

static void cmovnge_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnge %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnge_4 ... ok\n");
      }
      else
      {
         printf("cmovnge_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnge_4 ... failed\n");
   }

   return;
}

static void cmovnge_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnge_5 ... ok\n");
      }
      else
      {
         printf("cmovnge_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnge_5 ... failed\n");
   }

   return;
}

static void cmovnge_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnge_6 ... ok\n");
      }
      else
      {
         printf("cmovnge_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnge_6 ... failed\n");
   }

   return;
}

static void cmovnge_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnge_7 ... ok\n");
      }
      else
      {
         printf("cmovnge_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnge_7 ... failed\n");
   }

   return;
}

static void cmovnge_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnge_8 ... ok\n");
      }
      else
      {
         printf("cmovnge_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnge_8 ... failed\n");
   }

   return;
}

static void cmovnl_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnl_1 ... ok\n");
      }
      else
      {
         printf("cmovnl_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnl_1 ... failed\n");
   }

   return;
}

static void cmovnl_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnl_2 ... ok\n");
      }
      else
      {
         printf("cmovnl_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnl_2 ... failed\n");
   }

   return;
}

static void cmovnl_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnl_3 ... ok\n");
      }
      else
      {
         printf("cmovnl_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnl_3 ... failed\n");
   }

   return;
}

static void cmovnl_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnl %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnl_4 ... ok\n");
      }
      else
      {
         printf("cmovnl_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnl_4 ... failed\n");
   }

   return;
}

static void cmovnl_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnl_5 ... ok\n");
      }
      else
      {
         printf("cmovnl_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnl_5 ... failed\n");
   }

   return;
}

static void cmovnl_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnl_6 ... ok\n");
      }
      else
      {
         printf("cmovnl_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnl_6 ... failed\n");
   }

   return;
}

static void cmovnl_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnl_7 ... ok\n");
      }
      else
      {
         printf("cmovnl_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnl_7 ... failed\n");
   }

   return;
}

static void cmovnl_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnl_8 ... ok\n");
      }
      else
      {
         printf("cmovnl_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnl_8 ... failed\n");
   }

   return;
}

static void cmovnle_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnle_1 ... ok\n");
      }
      else
      {
         printf("cmovnle_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnle_1 ... failed\n");
   }

   return;
}

static void cmovnle_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_2 ... ok\n");
      }
      else
      {
         printf("cmovnle_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_2 ... failed\n");
   }

   return;
}

static void cmovnle_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_3 ... ok\n");
      }
      else
      {
         printf("cmovnle_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_3 ... failed\n");
   }

   return;
}

static void cmovnle_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_4 ... ok\n");
      }
      else
      {
         printf("cmovnle_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_4 ... failed\n");
   }

   return;
}

static void cmovnle_5(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_5 ... ok\n");
      }
      else
      {
         printf("cmovnle_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_5 ... failed\n");
   }

   return;
}

static void cmovnle_6(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_6 ... ok\n");
      }
      else
      {
         printf("cmovnle_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_6 ... failed\n");
   }

   return;
}

static void cmovnle_7(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnle_7 ... ok\n");
      }
      else
      {
         printf("cmovnle_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnle_7 ... failed\n");
   }

   return;
}

static void cmovnle_8(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_8 ... ok\n");
      }
      else
      {
         printf("cmovnle_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_8 ... failed\n");
   }

   return;
}

static void cmovnle_9(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnle_9 ... ok\n");
      }
      else
      {
         printf("cmovnle_9 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnle_9 ... failed\n");
   }

   return;
}

static void cmovnle_10(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_10 ... ok\n");
      }
      else
      {
         printf("cmovnle_10 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_10 ... failed\n");
   }

   return;
}

static void cmovnle_11(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_11 ... ok\n");
      }
      else
      {
         printf("cmovnle_11 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_11 ... failed\n");
   }

   return;
}

static void cmovnle_12(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_12 ... ok\n");
      }
      else
      {
         printf("cmovnle_12 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_12 ... failed\n");
   }

   return;
}

static void cmovnle_13(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_13 ... ok\n");
      }
      else
      {
         printf("cmovnle_13 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_13 ... failed\n");
   }

   return;
}

static void cmovnle_14(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_14 ... ok\n");
      }
      else
      {
         printf("cmovnle_14 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_14 ... failed\n");
   }

   return;
}

static void cmovnle_15(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnle_15 ... ok\n");
      }
      else
      {
         printf("cmovnle_15 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnle_15 ... failed\n");
   }

   return;
}

static void cmovnle_16(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnle_16 ... ok\n");
      }
      else
      {
         printf("cmovnle_16 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnle_16 ... failed\n");
   }

   return;
}

static void cmovno_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovno %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovno_1 ... ok\n");
      }
      else
      {
         printf("cmovno_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovno_1 ... failed\n");
   }

   return;
}

static void cmovno_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovno %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovno_2 ... ok\n");
      }
      else
      {
         printf("cmovno_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovno_2 ... failed\n");
   }

   return;
}

static void cmovno_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovno %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovno_3 ... ok\n");
      }
      else
      {
         printf("cmovno_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovno_3 ... failed\n");
   }

   return;
}

static void cmovno_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovno %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovno_4 ... ok\n");
      }
      else
      {
         printf("cmovno_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovno_4 ... failed\n");
   }

   return;
}

static void cmovnp_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnp %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnp_1 ... ok\n");
      }
      else
      {
         printf("cmovnp_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnp_1 ... failed\n");
   }

   return;
}

static void cmovnp_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovnp %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnp_2 ... ok\n");
      }
      else
      {
         printf("cmovnp_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnp_2 ... failed\n");
   }

   return;
}

static void cmovnp_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnp %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnp_3 ... ok\n");
      }
      else
      {
         printf("cmovnp_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnp_3 ... failed\n");
   }

   return;
}

static void cmovnp_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovnp %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnp_4 ... ok\n");
      }
      else
      {
         printf("cmovnp_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnp_4 ... failed\n");
   }

   return;
}

static void cmovns_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovns %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovns_1 ... ok\n");
      }
      else
      {
         printf("cmovns_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovns_1 ... failed\n");
   }

   return;
}

static void cmovns_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovns %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovns_2 ... ok\n");
      }
      else
      {
         printf("cmovns_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovns_2 ... failed\n");
   }

   return;
}

static void cmovns_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovns %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovns_3 ... ok\n");
      }
      else
      {
         printf("cmovns_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovns_3 ... failed\n");
   }

   return;
}

static void cmovns_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovns %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovns_4 ... ok\n");
      }
      else
      {
         printf("cmovns_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovns_4 ... failed\n");
   }

   return;
}

static void cmovnz_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnz %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnz_1 ... ok\n");
      }
      else
      {
         printf("cmovnz_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnz_1 ... failed\n");
   }

   return;
}

static void cmovnz_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnz %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnz_2 ... ok\n");
      }
      else
      {
         printf("cmovnz_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnz_2 ... failed\n");
   }

   return;
}

static void cmovnz_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnz %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovnz_3 ... ok\n");
      }
      else
      {
         printf("cmovnz_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovnz_3 ... failed\n");
   }

   return;
}

static void cmovnz_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnz %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovnz_4 ... ok\n");
      }
      else
      {
         printf("cmovnz_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovnz_4 ... failed\n");
   }

   return;
}

static void cmovo_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovo %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovo_1 ... ok\n");
      }
      else
      {
         printf("cmovo_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovo_1 ... failed\n");
   }

   return;
}

static void cmovo_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovo %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovo_2 ... ok\n");
      }
      else
      {
         printf("cmovo_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovo_2 ... failed\n");
   }

   return;
}

static void cmovo_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovo %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovo_3 ... ok\n");
      }
      else
      {
         printf("cmovo_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovo_3 ... failed\n");
   }

   return;
}

static void cmovo_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovo %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovo_4 ... ok\n");
      }
      else
      {
         printf("cmovo_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovo_4 ... failed\n");
   }

   return;
}

static void cmovp_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovp %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovp_1 ... ok\n");
      }
      else
      {
         printf("cmovp_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovp_1 ... failed\n");
   }

   return;
}

static void cmovp_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovp %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovp_2 ... ok\n");
      }
      else
      {
         printf("cmovp_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovp_2 ... failed\n");
   }

   return;
}

static void cmovp_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovp %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovp_3 ... ok\n");
      }
      else
      {
         printf("cmovp_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovp_3 ... failed\n");
   }

   return;
}

static void cmovp_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovp %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovp_4 ... ok\n");
      }
      else
      {
         printf("cmovp_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovp_4 ... failed\n");
   }

   return;
}

static void cmovs_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovs %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovs_1 ... ok\n");
      }
      else
      {
         printf("cmovs_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovs_1 ... failed\n");
   }

   return;
}

static void cmovs_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovs %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovs_2 ... ok\n");
      }
      else
      {
         printf("cmovs_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovs_2 ... failed\n");
   }

   return;
}

static void cmovs_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovs %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovs_3 ... ok\n");
      }
      else
      {
         printf("cmovs_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovs_3 ... failed\n");
   }

   return;
}

static void cmovs_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovs %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovs_4 ... ok\n");
      }
      else
      {
         printf("cmovs_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovs_4 ... failed\n");
   }

   return;
}

static void cmovz_1(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovz %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovz_1 ... ok\n");
      }
      else
      {
         printf("cmovz_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovz_1 ... failed\n");
   }

   return;
}

static void cmovz_2(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovz %%ax, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovz_2 ... ok\n");
      }
      else
      {
         printf("cmovz_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovz_2 ... failed\n");
   }

   return;
}

static void cmovz_3(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovz %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0 )
      {
         printf("cmovz_3 ... ok\n");
      }
      else
      {
         printf("cmovz_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0);
      }
   }
   else
   {
      printf("cmovz_3 ... failed\n");
   }

   return;
}

static void cmovz_4(void)
{
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %2, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovz %1, %%bx\n"
         "movw %%bx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 12345 )
      {
         printf("cmovz_4 ... ok\n");
      }
      else
      {
         printf("cmovz_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 12345);
      }
   }
   else
   {
      printf("cmovz_4 ... failed\n");
   }

   return;
}

static void cmova_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmova %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmova_9 ... ok\n");
      }
      else
      {
         printf("cmova_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmova_9 ... failed\n");
   }

   return;
}

static void cmova_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmova %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_10 ... ok\n");
      }
      else
      {
         printf("cmova_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_10 ... failed\n");
   }

   return;
}

static void cmova_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmova %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_11 ... ok\n");
      }
      else
      {
         printf("cmova_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_11 ... failed\n");
   }

   return;
}

static void cmova_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmova %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_12 ... ok\n");
      }
      else
      {
         printf("cmova_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_12 ... failed\n");
   }

   return;
}

static void cmova_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmova_13 ... ok\n");
      }
      else
      {
         printf("cmova_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmova_13 ... failed\n");
   }

   return;
}

static void cmova_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_14 ... ok\n");
      }
      else
      {
         printf("cmova_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_14 ... failed\n");
   }

   return;
}

static void cmova_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_15 ... ok\n");
      }
      else
      {
         printf("cmova_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_15 ... failed\n");
   }

   return;
}

static void cmova_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmova %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmova_16 ... ok\n");
      }
      else
      {
         printf("cmova_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmova_16 ... failed\n");
   }

   return;
}

static void cmovae_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovae %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovae_5 ... ok\n");
      }
      else
      {
         printf("cmovae_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovae_5 ... failed\n");
   }

   return;
}

static void cmovae_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovae %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovae_6 ... ok\n");
      }
      else
      {
         printf("cmovae_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovae_6 ... failed\n");
   }

   return;
}

static void cmovae_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovae %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovae_7 ... ok\n");
      }
      else
      {
         printf("cmovae_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovae_7 ... failed\n");
   }

   return;
}

static void cmovae_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovae %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovae_8 ... ok\n");
      }
      else
      {
         printf("cmovae_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovae_8 ... failed\n");
   }

   return;
}

static void cmovb_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovb %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovb_5 ... ok\n");
      }
      else
      {
         printf("cmovb_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovb_5 ... failed\n");
   }

   return;
}

static void cmovb_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovb %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovb_6 ... ok\n");
      }
      else
      {
         printf("cmovb_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovb_6 ... failed\n");
   }

   return;
}

static void cmovb_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovb %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovb_7 ... ok\n");
      }
      else
      {
         printf("cmovb_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovb_7 ... failed\n");
   }

   return;
}

static void cmovb_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovb %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovb_8 ... ok\n");
      }
      else
      {
         printf("cmovb_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovb_8 ... failed\n");
   }

   return;
}

static void cmovbe_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovbe_9 ... ok\n");
      }
      else
      {
         printf("cmovbe_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovbe_9 ... failed\n");
   }

   return;
}

static void cmovbe_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_10 ... ok\n");
      }
      else
      {
         printf("cmovbe_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_10 ... failed\n");
   }

   return;
}

static void cmovbe_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_11 ... ok\n");
      }
      else
      {
         printf("cmovbe_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_11 ... failed\n");
   }

   return;
}

static void cmovbe_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_12 ... ok\n");
      }
      else
      {
         printf("cmovbe_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_12 ... failed\n");
   }

   return;
}

static void cmovbe_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovbe_13 ... ok\n");
      }
      else
      {
         printf("cmovbe_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovbe_13 ... failed\n");
   }

   return;
}

static void cmovbe_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_14 ... ok\n");
      }
      else
      {
         printf("cmovbe_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_14 ... failed\n");
   }

   return;
}

static void cmovbe_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_15 ... ok\n");
      }
      else
      {
         printf("cmovbe_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_15 ... failed\n");
   }

   return;
}

static void cmovbe_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovbe_16 ... ok\n");
      }
      else
      {
         printf("cmovbe_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovbe_16 ... failed\n");
   }

   return;
}

static void cmovc_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovc %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovc_5 ... ok\n");
      }
      else
      {
         printf("cmovc_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovc_5 ... failed\n");
   }

   return;
}

static void cmovc_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovc %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovc_6 ... ok\n");
      }
      else
      {
         printf("cmovc_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovc_6 ... failed\n");
   }

   return;
}

static void cmovc_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovc %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovc_7 ... ok\n");
      }
      else
      {
         printf("cmovc_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovc_7 ... failed\n");
   }

   return;
}

static void cmovc_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovc %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovc_8 ... ok\n");
      }
      else
      {
         printf("cmovc_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovc_8 ... failed\n");
   }

   return;
}

static void cmove_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmove %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmove_5 ... ok\n");
      }
      else
      {
         printf("cmove_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmove_5 ... failed\n");
   }

   return;
}

static void cmove_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmove %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmove_6 ... ok\n");
      }
      else
      {
         printf("cmove_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmove_6 ... failed\n");
   }

   return;
}

static void cmove_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmove %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmove_7 ... ok\n");
      }
      else
      {
         printf("cmove_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmove_7 ... failed\n");
   }

   return;
}

static void cmove_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmove %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmove_8 ... ok\n");
      }
      else
      {
         printf("cmove_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmove_8 ... failed\n");
   }

   return;
}

static void cmovg_17(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovg_17 ... ok\n");
      }
      else
      {
         printf("cmovg_17 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovg_17 ... failed\n");
   }

   return;
}

static void cmovg_18(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_18 ... ok\n");
      }
      else
      {
         printf("cmovg_18 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_18 ... failed\n");
   }

   return;
}

static void cmovg_19(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_19 ... ok\n");
      }
      else
      {
         printf("cmovg_19 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_19 ... failed\n");
   }

   return;
}

static void cmovg_20(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_20 ... ok\n");
      }
      else
      {
         printf("cmovg_20 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_20 ... failed\n");
   }

   return;
}

static void cmovg_21(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_21 ... ok\n");
      }
      else
      {
         printf("cmovg_21 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_21 ... failed\n");
   }

   return;
}

static void cmovg_22(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_22 ... ok\n");
      }
      else
      {
         printf("cmovg_22 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_22 ... failed\n");
   }

   return;
}

static void cmovg_23(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovg_23 ... ok\n");
      }
      else
      {
         printf("cmovg_23 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovg_23 ... failed\n");
   }

   return;
}

static void cmovg_24(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovg %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_24 ... ok\n");
      }
      else
      {
         printf("cmovg_24 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_24 ... failed\n");
   }

   return;
}

static void cmovg_25(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovg_25 ... ok\n");
      }
      else
      {
         printf("cmovg_25 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovg_25 ... failed\n");
   }

   return;
}

static void cmovg_26(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_26 ... ok\n");
      }
      else
      {
         printf("cmovg_26 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_26 ... failed\n");
   }

   return;
}

static void cmovg_27(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_27 ... ok\n");
      }
      else
      {
         printf("cmovg_27 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_27 ... failed\n");
   }

   return;
}

static void cmovg_28(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_28 ... ok\n");
      }
      else
      {
         printf("cmovg_28 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_28 ... failed\n");
   }

   return;
}

static void cmovg_29(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_29 ... ok\n");
      }
      else
      {
         printf("cmovg_29 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_29 ... failed\n");
   }

   return;
}

static void cmovg_30(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_30 ... ok\n");
      }
      else
      {
         printf("cmovg_30 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_30 ... failed\n");
   }

   return;
}

static void cmovg_31(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovg_31 ... ok\n");
      }
      else
      {
         printf("cmovg_31 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovg_31 ... failed\n");
   }

   return;
}

static void cmovg_32(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovg %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovg_32 ... ok\n");
      }
      else
      {
         printf("cmovg_32 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovg_32 ... failed\n");
   }

   return;
}

static void cmovge_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovge_9 ... ok\n");
      }
      else
      {
         printf("cmovge_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovge_9 ... failed\n");
   }

   return;
}

static void cmovge_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovge_10 ... ok\n");
      }
      else
      {
         printf("cmovge_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovge_10 ... failed\n");
   }

   return;
}

static void cmovge_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovge_11 ... ok\n");
      }
      else
      {
         printf("cmovge_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovge_11 ... failed\n");
   }

   return;
}

static void cmovge_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovge_12 ... ok\n");
      }
      else
      {
         printf("cmovge_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovge_12 ... failed\n");
   }

   return;
}

static void cmovge_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovge_13 ... ok\n");
      }
      else
      {
         printf("cmovge_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovge_13 ... failed\n");
   }

   return;
}

static void cmovge_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovge_14 ... ok\n");
      }
      else
      {
         printf("cmovge_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovge_14 ... failed\n");
   }

   return;
}

static void cmovge_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovge_15 ... ok\n");
      }
      else
      {
         printf("cmovge_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovge_15 ... failed\n");
   }

   return;
}

static void cmovge_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovge_16 ... ok\n");
      }
      else
      {
         printf("cmovge_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovge_16 ... failed\n");
   }

   return;
}

static void cmovl_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovl_9 ... ok\n");
      }
      else
      {
         printf("cmovl_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovl_9 ... failed\n");
   }

   return;
}

static void cmovl_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovl_10 ... ok\n");
      }
      else
      {
         printf("cmovl_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovl_10 ... failed\n");
   }

   return;
}

static void cmovl_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovl_11 ... ok\n");
      }
      else
      {
         printf("cmovl_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovl_11 ... failed\n");
   }

   return;
}

static void cmovl_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovl_12 ... ok\n");
      }
      else
      {
         printf("cmovl_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovl_12 ... failed\n");
   }

   return;
}

static void cmovl_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovl_13 ... ok\n");
      }
      else
      {
         printf("cmovl_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovl_13 ... failed\n");
   }

   return;
}

static void cmovl_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovl_14 ... ok\n");
      }
      else
      {
         printf("cmovl_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovl_14 ... failed\n");
   }

   return;
}

static void cmovl_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovl_15 ... ok\n");
      }
      else
      {
         printf("cmovl_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovl_15 ... failed\n");
   }

   return;
}

static void cmovl_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovl_16 ... ok\n");
      }
      else
      {
         printf("cmovl_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovl_16 ... failed\n");
   }

   return;
}

static void cmovle_17(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovle_17 ... ok\n");
      }
      else
      {
         printf("cmovle_17 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovle_17 ... failed\n");
   }

   return;
}

static void cmovle_18(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_18 ... ok\n");
      }
      else
      {
         printf("cmovle_18 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_18 ... failed\n");
   }

   return;
}

static void cmovle_19(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_19 ... ok\n");
      }
      else
      {
         printf("cmovle_19 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_19 ... failed\n");
   }

   return;
}

static void cmovle_20(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_20 ... ok\n");
      }
      else
      {
         printf("cmovle_20 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_20 ... failed\n");
   }

   return;
}

static void cmovle_21(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_21 ... ok\n");
      }
      else
      {
         printf("cmovle_21 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_21 ... failed\n");
   }

   return;
}

static void cmovle_22(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_22 ... ok\n");
      }
      else
      {
         printf("cmovle_22 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_22 ... failed\n");
   }

   return;
}

static void cmovle_23(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovle_23 ... ok\n");
      }
      else
      {
         printf("cmovle_23 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovle_23 ... failed\n");
   }

   return;
}

static void cmovle_24(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_24 ... ok\n");
      }
      else
      {
         printf("cmovle_24 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_24 ... failed\n");
   }

   return;
}

static void cmovle_25(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovle_25 ... ok\n");
      }
      else
      {
         printf("cmovle_25 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovle_25 ... failed\n");
   }

   return;
}

static void cmovle_26(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_26 ... ok\n");
      }
      else
      {
         printf("cmovle_26 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_26 ... failed\n");
   }

   return;
}

static void cmovle_27(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_27 ... ok\n");
      }
      else
      {
         printf("cmovle_27 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_27 ... failed\n");
   }

   return;
}

static void cmovle_28(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_28 ... ok\n");
      }
      else
      {
         printf("cmovle_28 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_28 ... failed\n");
   }

   return;
}

static void cmovle_29(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_29 ... ok\n");
      }
      else
      {
         printf("cmovle_29 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_29 ... failed\n");
   }

   return;
}

static void cmovle_30(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_30 ... ok\n");
      }
      else
      {
         printf("cmovle_30 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_30 ... failed\n");
   }

   return;
}

static void cmovle_31(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovle_31 ... ok\n");
      }
      else
      {
         printf("cmovle_31 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovle_31 ... failed\n");
   }

   return;
}

static void cmovle_32(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovle_32 ... ok\n");
      }
      else
      {
         printf("cmovle_32 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovle_32 ... failed\n");
   }

   return;
}

static void cmovna_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovna %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovna_9 ... ok\n");
      }
      else
      {
         printf("cmovna_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovna_9 ... failed\n");
   }

   return;
}

static void cmovna_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovna %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_10 ... ok\n");
      }
      else
      {
         printf("cmovna_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_10 ... failed\n");
   }

   return;
}

static void cmovna_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovna %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_11 ... ok\n");
      }
      else
      {
         printf("cmovna_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_11 ... failed\n");
   }

   return;
}

static void cmovna_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovna %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_12 ... ok\n");
      }
      else
      {
         printf("cmovna_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_12 ... failed\n");
   }

   return;
}

static void cmovna_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovna_13 ... ok\n");
      }
      else
      {
         printf("cmovna_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovna_13 ... failed\n");
   }

   return;
}

static void cmovna_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_14 ... ok\n");
      }
      else
      {
         printf("cmovna_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_14 ... failed\n");
   }

   return;
}

static void cmovna_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_15 ... ok\n");
      }
      else
      {
         printf("cmovna_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_15 ... failed\n");
   }

   return;
}

static void cmovna_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovna %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovna_16 ... ok\n");
      }
      else
      {
         printf("cmovna_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovna_16 ... failed\n");
   }

   return;
}

static void cmovnae_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnae %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnae_5 ... ok\n");
      }
      else
      {
         printf("cmovnae_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnae_5 ... failed\n");
   }

   return;
}

static void cmovnae_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnae %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnae_6 ... ok\n");
      }
      else
      {
         printf("cmovnae_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnae_6 ... failed\n");
   }

   return;
}

static void cmovnae_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnae %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnae_7 ... ok\n");
      }
      else
      {
         printf("cmovnae_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnae_7 ... failed\n");
   }

   return;
}

static void cmovnae_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnae %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnae_8 ... ok\n");
      }
      else
      {
         printf("cmovnae_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnae_8 ... failed\n");
   }

   return;
}

static void cmovnb_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnb %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnb_5 ... ok\n");
      }
      else
      {
         printf("cmovnb_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnb_5 ... failed\n");
   }

   return;
}

static void cmovnb_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnb %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnb_6 ... ok\n");
      }
      else
      {
         printf("cmovnb_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnb_6 ... failed\n");
   }

   return;
}

static void cmovnb_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnb %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnb_7 ... ok\n");
      }
      else
      {
         printf("cmovnb_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnb_7 ... failed\n");
   }

   return;
}

static void cmovnb_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnb %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnb_8 ... ok\n");
      }
      else
      {
         printf("cmovnb_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnb_8 ... failed\n");
   }

   return;
}

static void cmovnbe_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnbe_9 ... ok\n");
      }
      else
      {
         printf("cmovnbe_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnbe_9 ... failed\n");
   }

   return;
}

static void cmovnbe_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_10 ... ok\n");
      }
      else
      {
         printf("cmovnbe_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_10 ... failed\n");
   }

   return;
}

static void cmovnbe_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_11 ... ok\n");
      }
      else
      {
         printf("cmovnbe_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_11 ... failed\n");
   }

   return;
}

static void cmovnbe_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovnbe %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_12 ... ok\n");
      }
      else
      {
         printf("cmovnbe_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_12 ... failed\n");
   }

   return;
}

static void cmovnbe_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnbe_13 ... ok\n");
      }
      else
      {
         printf("cmovnbe_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnbe_13 ... failed\n");
   }

   return;
}

static void cmovnbe_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_14 ... ok\n");
      }
      else
      {
         printf("cmovnbe_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_14 ... failed\n");
   }

   return;
}

static void cmovnbe_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_15 ... ok\n");
      }
      else
      {
         printf("cmovnbe_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_15 ... failed\n");
   }

   return;
}

static void cmovnbe_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "cmovnbe %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnbe_16 ... ok\n");
      }
      else
      {
         printf("cmovnbe_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnbe_16 ... failed\n");
   }

   return;
}

static void cmovnc_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnc %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnc_5 ... ok\n");
      }
      else
      {
         printf("cmovnc_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnc_5 ... failed\n");
   }

   return;
}

static void cmovnc_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnc %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnc_6 ... ok\n");
      }
      else
      {
         printf("cmovnc_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnc_6 ... failed\n");
   }

   return;
}

static void cmovnc_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnc %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnc_7 ... ok\n");
      }
      else
      {
         printf("cmovnc_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnc_7 ... failed\n");
   }

   return;
}

static void cmovnc_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmovnc %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnc_8 ... ok\n");
      }
      else
      {
         printf("cmovnc_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnc_8 ... failed\n");
   }

   return;
}

static void cmovne_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovne %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovne_5 ... ok\n");
      }
      else
      {
         printf("cmovne_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovne_5 ... failed\n");
   }

   return;
}

static void cmovne_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovne %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovne_6 ... ok\n");
      }
      else
      {
         printf("cmovne_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovne_6 ... failed\n");
   }

   return;
}

static void cmovne_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovne %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovne_7 ... ok\n");
      }
      else
      {
         printf("cmovne_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovne_7 ... failed\n");
   }

   return;
}

static void cmovne_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovne %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovne_8 ... ok\n");
      }
      else
      {
         printf("cmovne_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovne_8 ... failed\n");
   }

   return;
}

static void cmovng_17(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovng_17 ... ok\n");
      }
      else
      {
         printf("cmovng_17 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovng_17 ... failed\n");
   }

   return;
}

static void cmovng_18(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_18 ... ok\n");
      }
      else
      {
         printf("cmovng_18 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_18 ... failed\n");
   }

   return;
}

static void cmovng_19(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_19 ... ok\n");
      }
      else
      {
         printf("cmovng_19 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_19 ... failed\n");
   }

   return;
}

static void cmovng_20(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_20 ... ok\n");
      }
      else
      {
         printf("cmovng_20 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_20 ... failed\n");
   }

   return;
}

static void cmovng_21(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_21 ... ok\n");
      }
      else
      {
         printf("cmovng_21 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_21 ... failed\n");
   }

   return;
}

static void cmovng_22(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_22 ... ok\n");
      }
      else
      {
         printf("cmovng_22 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_22 ... failed\n");
   }

   return;
}

static void cmovng_23(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovng_23 ... ok\n");
      }
      else
      {
         printf("cmovng_23 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovng_23 ... failed\n");
   }

   return;
}

static void cmovng_24(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovng %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_24 ... ok\n");
      }
      else
      {
         printf("cmovng_24 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_24 ... failed\n");
   }

   return;
}

static void cmovng_25(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovng_25 ... ok\n");
      }
      else
      {
         printf("cmovng_25 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovng_25 ... failed\n");
   }

   return;
}

static void cmovng_26(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_26 ... ok\n");
      }
      else
      {
         printf("cmovng_26 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_26 ... failed\n");
   }

   return;
}

static void cmovng_27(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_27 ... ok\n");
      }
      else
      {
         printf("cmovng_27 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_27 ... failed\n");
   }

   return;
}

static void cmovng_28(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_28 ... ok\n");
      }
      else
      {
         printf("cmovng_28 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_28 ... failed\n");
   }

   return;
}

static void cmovng_29(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_29 ... ok\n");
      }
      else
      {
         printf("cmovng_29 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_29 ... failed\n");
   }

   return;
}

static void cmovng_30(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_30 ... ok\n");
      }
      else
      {
         printf("cmovng_30 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_30 ... failed\n");
   }

   return;
}

static void cmovng_31(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovng_31 ... ok\n");
      }
      else
      {
         printf("cmovng_31 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovng_31 ... failed\n");
   }

   return;
}

static void cmovng_32(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovng %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovng_32 ... ok\n");
      }
      else
      {
         printf("cmovng_32 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovng_32 ... failed\n");
   }

   return;
}

static void cmovnge_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnge_9 ... ok\n");
      }
      else
      {
         printf("cmovnge_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnge_9 ... failed\n");
   }

   return;
}

static void cmovnge_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnge_10 ... ok\n");
      }
      else
      {
         printf("cmovnge_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnge_10 ... failed\n");
   }

   return;
}

static void cmovnge_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnge_11 ... ok\n");
      }
      else
      {
         printf("cmovnge_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnge_11 ... failed\n");
   }

   return;
}

static void cmovnge_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnge %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnge_12 ... ok\n");
      }
      else
      {
         printf("cmovnge_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnge_12 ... failed\n");
   }

   return;
}

static void cmovnge_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnge_13 ... ok\n");
      }
      else
      {
         printf("cmovnge_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnge_13 ... failed\n");
   }

   return;
}

static void cmovnge_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnge_14 ... ok\n");
      }
      else
      {
         printf("cmovnge_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnge_14 ... failed\n");
   }

   return;
}

static void cmovnge_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnge_15 ... ok\n");
      }
      else
      {
         printf("cmovnge_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnge_15 ... failed\n");
   }

   return;
}

static void cmovnge_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnge %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnge_16 ... ok\n");
      }
      else
      {
         printf("cmovnge_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnge_16 ... failed\n");
   }

   return;
}

static void cmovnl_9(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnl_9 ... ok\n");
      }
      else
      {
         printf("cmovnl_9 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnl_9 ... failed\n");
   }

   return;
}

static void cmovnl_10(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnl_10 ... ok\n");
      }
      else
      {
         printf("cmovnl_10 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnl_10 ... failed\n");
   }

   return;
}

static void cmovnl_11(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnl_11 ... ok\n");
      }
      else
      {
         printf("cmovnl_11 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnl_11 ... failed\n");
   }

   return;
}

static void cmovnl_12(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnl %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnl_12 ... ok\n");
      }
      else
      {
         printf("cmovnl_12 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnl_12 ... failed\n");
   }

   return;
}

static void cmovnl_13(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnl_13 ... ok\n");
      }
      else
      {
         printf("cmovnl_13 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnl_13 ... failed\n");
   }

   return;
}

static void cmovnl_14(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnl_14 ... ok\n");
      }
      else
      {
         printf("cmovnl_14 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnl_14 ... failed\n");
   }

   return;
}

static void cmovnl_15(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnl_15 ... ok\n");
      }
      else
      {
         printf("cmovnl_15 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnl_15 ... failed\n");
   }

   return;
}

static void cmovnl_16(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnl %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnl_16 ... ok\n");
      }
      else
      {
         printf("cmovnl_16 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnl_16 ... failed\n");
   }

   return;
}

static void cmovnle_17(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnle_17 ... ok\n");
      }
      else
      {
         printf("cmovnle_17 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnle_17 ... failed\n");
   }

   return;
}

static void cmovnle_18(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_18 ... ok\n");
      }
      else
      {
         printf("cmovnle_18 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_18 ... failed\n");
   }

   return;
}

static void cmovnle_19(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_19 ... ok\n");
      }
      else
      {
         printf("cmovnle_19 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_19 ... failed\n");
   }

   return;
}

static void cmovnle_20(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_20 ... ok\n");
      }
      else
      {
         printf("cmovnle_20 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_20 ... failed\n");
   }

   return;
}

static void cmovnle_21(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_21 ... ok\n");
      }
      else
      {
         printf("cmovnle_21 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_21 ... failed\n");
   }

   return;
}

static void cmovnle_22(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_22 ... ok\n");
      }
      else
      {
         printf("cmovnle_22 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_22 ... failed\n");
   }

   return;
}

static void cmovnle_23(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnle_23 ... ok\n");
      }
      else
      {
         printf("cmovnle_23 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnle_23 ... failed\n");
   }

   return;
}

static void cmovnle_24(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_24 ... ok\n");
      }
      else
      {
         printf("cmovnle_24 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_24 ... failed\n");
   }

   return;
}

static void cmovnle_25(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnle_25 ... ok\n");
      }
      else
      {
         printf("cmovnle_25 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnle_25 ... failed\n");
   }

   return;
}

static void cmovnle_26(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_26 ... ok\n");
      }
      else
      {
         printf("cmovnle_26 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_26 ... failed\n");
   }

   return;
}

static void cmovnle_27(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_27 ... ok\n");
      }
      else
      {
         printf("cmovnle_27 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_27 ... failed\n");
   }

   return;
}

static void cmovnle_28(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_28 ... ok\n");
      }
      else
      {
         printf("cmovnle_28 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_28 ... failed\n");
   }

   return;
}

static void cmovnle_29(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_29 ... ok\n");
      }
      else
      {
         printf("cmovnle_29 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_29 ... failed\n");
   }

   return;
}

static void cmovnle_30(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_30 ... ok\n");
      }
      else
      {
         printf("cmovnle_30 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_30 ... failed\n");
   }

   return;
}

static void cmovnle_31(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnle_31 ... ok\n");
      }
      else
      {
         printf("cmovnle_31 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnle_31 ... failed\n");
   }

   return;
}

static void cmovnle_32(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "cmovnle %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnle_32 ... ok\n");
      }
      else
      {
         printf("cmovnle_32 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnle_32 ... failed\n");
   }

   return;
}

static void cmovno_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovno %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovno_5 ... ok\n");
      }
      else
      {
         printf("cmovno_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovno_5 ... failed\n");
   }

   return;
}

static void cmovno_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovno %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovno_6 ... ok\n");
      }
      else
      {
         printf("cmovno_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovno_6 ... failed\n");
   }

   return;
}

static void cmovno_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovno %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovno_7 ... ok\n");
      }
      else
      {
         printf("cmovno_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovno_7 ... failed\n");
   }

   return;
}

static void cmovno_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovno %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovno_8 ... ok\n");
      }
      else
      {
         printf("cmovno_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovno_8 ... failed\n");
   }

   return;
}

static void cmovnp_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnp %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnp_5 ... ok\n");
      }
      else
      {
         printf("cmovnp_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnp_5 ... failed\n");
   }

   return;
}

static void cmovnp_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovnp %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnp_6 ... ok\n");
      }
      else
      {
         printf("cmovnp_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnp_6 ... failed\n");
   }

   return;
}

static void cmovnp_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnp %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnp_7 ... ok\n");
      }
      else
      {
         printf("cmovnp_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnp_7 ... failed\n");
   }

   return;
}

static void cmovnp_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovnp %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnp_8 ... ok\n");
      }
      else
      {
         printf("cmovnp_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnp_8 ... failed\n");
   }

   return;
}

static void cmovns_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovns %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovns_5 ... ok\n");
      }
      else
      {
         printf("cmovns_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovns_5 ... failed\n");
   }

   return;
}

static void cmovns_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovns %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovns_6 ... ok\n");
      }
      else
      {
         printf("cmovns_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovns_6 ... failed\n");
   }

   return;
}

static void cmovns_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovns %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovns_7 ... ok\n");
      }
      else
      {
         printf("cmovns_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovns_7 ... failed\n");
   }

   return;
}

static void cmovns_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovns %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovns_8 ... ok\n");
      }
      else
      {
         printf("cmovns_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovns_8 ... failed\n");
   }

   return;
}

static void cmovnz_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnz %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnz_5 ... ok\n");
      }
      else
      {
         printf("cmovnz_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnz_5 ... failed\n");
   }

   return;
}

static void cmovnz_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnz %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnz_6 ... ok\n");
      }
      else
      {
         printf("cmovnz_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnz_6 ... failed\n");
   }

   return;
}

static void cmovnz_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovnz %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovnz_7 ... ok\n");
      }
      else
      {
         printf("cmovnz_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovnz_7 ... failed\n");
   }

   return;
}

static void cmovnz_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovnz %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovnz_8 ... ok\n");
      }
      else
      {
         printf("cmovnz_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovnz_8 ... failed\n");
   }

   return;
}

static void cmovo_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovo %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovo_5 ... ok\n");
      }
      else
      {
         printf("cmovo_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovo_5 ... failed\n");
   }

   return;
}

static void cmovo_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovo %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovo_6 ... ok\n");
      }
      else
      {
         printf("cmovo_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovo_6 ... failed\n");
   }

   return;
}

static void cmovo_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovo %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovo_7 ... ok\n");
      }
      else
      {
         printf("cmovo_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovo_7 ... failed\n");
   }

   return;
}

static void cmovo_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmovo %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovo_8 ... ok\n");
      }
      else
      {
         printf("cmovo_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovo_8 ... failed\n");
   }

   return;
}

static void cmovp_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovp %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovp_5 ... ok\n");
      }
      else
      {
         printf("cmovp_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovp_5 ... failed\n");
   }

   return;
}

static void cmovp_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovp %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovp_6 ... ok\n");
      }
      else
      {
         printf("cmovp_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovp_6 ... failed\n");
   }

   return;
}

static void cmovp_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovp %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovp_7 ... ok\n");
      }
      else
      {
         printf("cmovp_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovp_7 ... failed\n");
   }

   return;
}

static void cmovp_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "cmovp %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovp_8 ... ok\n");
      }
      else
      {
         printf("cmovp_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovp_8 ... failed\n");
   }

   return;
}

static void cmovs_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovs %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovs_5 ... ok\n");
      }
      else
      {
         printf("cmovs_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovs_5 ... failed\n");
   }

   return;
}

static void cmovs_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovs %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovs_6 ... ok\n");
      }
      else
      {
         printf("cmovs_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovs_6 ... failed\n");
   }

   return;
}

static void cmovs_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovs %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovs_7 ... ok\n");
      }
      else
      {
         printf("cmovs_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovs_7 ... failed\n");
   }

   return;
}

static void cmovs_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "cmovs %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovs_8 ... ok\n");
      }
      else
      {
         printf("cmovs_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovs_8 ... failed\n");
   }

   return;
}

static void cmovz_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovz %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovz_5 ... ok\n");
      }
      else
      {
         printf("cmovz_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovz_5 ... failed\n");
   }

   return;
}

static void cmovz_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovz %%eax, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovz_6 ... ok\n");
      }
      else
      {
         printf("cmovz_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovz_6 ... failed\n");
   }

   return;
}

static void cmovz_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmovz %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0UL )
      {
         printf("cmovz_7 ... ok\n");
      }
      else
      {
         printf("cmovz_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0UL);
      }
   }
   else
   {
      printf("cmovz_7 ... failed\n");
   }

   return;
}

static void cmovz_8(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %2, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmovz %1, %%ebx\n"
         "movl %%ebx, %0\n"
         "frstor %3\n"
         "cld\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 12345678UL )
      {
         printf("cmovz_8 ... ok\n");
      }
      else
      {
         printf("cmovz_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("cmovz_8 ... failed\n");
   }

   return;
}

int main(int argc, char **argv)
{
   signal(SIGILL, handle_sigill);

   cmova_1();
   cmova_2();
   cmova_3();
   cmova_4();
   cmova_5();
   cmova_6();
   cmova_7();
   cmova_8();
   cmovae_1();
   cmovae_2();
   cmovae_3();
   cmovae_4();
   cmovb_1();
   cmovb_2();
   cmovb_3();
   cmovb_4();
   cmovbe_1();
   cmovbe_2();
   cmovbe_3();
   cmovbe_4();
   cmovbe_5();
   cmovbe_6();
   cmovbe_7();
   cmovbe_8();
   cmovc_1();
   cmovc_2();
   cmovc_3();
   cmovc_4();
   cmove_1();
   cmove_2();
   cmove_3();
   cmove_4();
   cmovg_1();
   cmovg_2();
   cmovg_3();
   cmovg_4();
   cmovg_5();
   cmovg_6();
   cmovg_7();
   cmovg_8();
   cmovg_9();
   cmovg_10();
   cmovg_11();
   cmovg_12();
   cmovg_13();
   cmovg_14();
   cmovg_15();
   cmovg_16();
   cmovge_1();
   cmovge_2();
   cmovge_3();
   cmovge_4();
   cmovge_5();
   cmovge_6();
   cmovge_7();
   cmovge_8();
   cmovl_1();
   cmovl_2();
   cmovl_3();
   cmovl_4();
   cmovl_5();
   cmovl_6();
   cmovl_7();
   cmovl_8();
   cmovle_1();
   cmovle_2();
   cmovle_3();
   cmovle_4();
   cmovle_5();
   cmovle_6();
   cmovle_7();
   cmovle_8();
   cmovle_9();
   cmovle_10();
   cmovle_11();
   cmovle_12();
   cmovle_13();
   cmovle_14();
   cmovle_15();
   cmovle_16();
   cmovna_1();
   cmovna_2();
   cmovna_3();
   cmovna_4();
   cmovna_5();
   cmovna_6();
   cmovna_7();
   cmovna_8();
   cmovnae_1();
   cmovnae_2();
   cmovnae_3();
   cmovnae_4();
   cmovnb_1();
   cmovnb_2();
   cmovnb_3();
   cmovnb_4();
   cmovnbe_1();
   cmovnbe_2();
   cmovnbe_3();
   cmovnbe_4();
   cmovnbe_5();
   cmovnbe_6();
   cmovnbe_7();
   cmovnbe_8();
   cmovnc_1();
   cmovnc_2();
   cmovnc_3();
   cmovnc_4();
   cmovne_1();
   cmovne_2();
   cmovne_3();
   cmovne_4();
   cmovng_1();
   cmovng_2();
   cmovng_3();
   cmovng_4();
   cmovng_5();
   cmovng_6();
   cmovng_7();
   cmovng_8();
   cmovng_9();
   cmovng_10();
   cmovng_11();
   cmovng_12();
   cmovng_13();
   cmovng_14();
   cmovng_15();
   cmovng_16();
   cmovnge_1();
   cmovnge_2();
   cmovnge_3();
   cmovnge_4();
   cmovnge_5();
   cmovnge_6();
   cmovnge_7();
   cmovnge_8();
   cmovnl_1();
   cmovnl_2();
   cmovnl_3();
   cmovnl_4();
   cmovnl_5();
   cmovnl_6();
   cmovnl_7();
   cmovnl_8();
   cmovnle_1();
   cmovnle_2();
   cmovnle_3();
   cmovnle_4();
   cmovnle_5();
   cmovnle_6();
   cmovnle_7();
   cmovnle_8();
   cmovnle_9();
   cmovnle_10();
   cmovnle_11();
   cmovnle_12();
   cmovnle_13();
   cmovnle_14();
   cmovnle_15();
   cmovnle_16();
   cmovno_1();
   cmovno_2();
   cmovno_3();
   cmovno_4();
   cmovnp_1();
   cmovnp_2();
   cmovnp_3();
   cmovnp_4();
   cmovns_1();
   cmovns_2();
   cmovns_3();
   cmovns_4();
   cmovnz_1();
   cmovnz_2();
   cmovnz_3();
   cmovnz_4();
   cmovo_1();
   cmovo_2();
   cmovo_3();
   cmovo_4();
   cmovp_1();
   cmovp_2();
   cmovp_3();
   cmovp_4();
   cmovs_1();
   cmovs_2();
   cmovs_3();
   cmovs_4();
   cmovz_1();
   cmovz_2();
   cmovz_3();
   cmovz_4();
   cmova_9();
   cmova_10();
   cmova_11();
   cmova_12();
   cmova_13();
   cmova_14();
   cmova_15();
   cmova_16();
   cmovae_5();
   cmovae_6();
   cmovae_7();
   cmovae_8();
   cmovb_5();
   cmovb_6();
   cmovb_7();
   cmovb_8();
   cmovbe_9();
   cmovbe_10();
   cmovbe_11();
   cmovbe_12();
   cmovbe_13();
   cmovbe_14();
   cmovbe_15();
   cmovbe_16();
   cmovc_5();
   cmovc_6();
   cmovc_7();
   cmovc_8();
   cmove_5();
   cmove_6();
   cmove_7();
   cmove_8();
   cmovg_17();
   cmovg_18();
   cmovg_19();
   cmovg_20();
   cmovg_21();
   cmovg_22();
   cmovg_23();
   cmovg_24();
   cmovg_25();
   cmovg_26();
   cmovg_27();
   cmovg_28();
   cmovg_29();
   cmovg_30();
   cmovg_31();
   cmovg_32();
   cmovge_9();
   cmovge_10();
   cmovge_11();
   cmovge_12();
   cmovge_13();
   cmovge_14();
   cmovge_15();
   cmovge_16();
   cmovl_9();
   cmovl_10();
   cmovl_11();
   cmovl_12();
   cmovl_13();
   cmovl_14();
   cmovl_15();
   cmovl_16();
   cmovle_17();
   cmovle_18();
   cmovle_19();
   cmovle_20();
   cmovle_21();
   cmovle_22();
   cmovle_23();
   cmovle_24();
   cmovle_25();
   cmovle_26();
   cmovle_27();
   cmovle_28();
   cmovle_29();
   cmovle_30();
   cmovle_31();
   cmovle_32();
   cmovna_9();
   cmovna_10();
   cmovna_11();
   cmovna_12();
   cmovna_13();
   cmovna_14();
   cmovna_15();
   cmovna_16();
   cmovnae_5();
   cmovnae_6();
   cmovnae_7();
   cmovnae_8();
   cmovnb_5();
   cmovnb_6();
   cmovnb_7();
   cmovnb_8();
   cmovnbe_9();
   cmovnbe_10();
   cmovnbe_11();
   cmovnbe_12();
   cmovnbe_13();
   cmovnbe_14();
   cmovnbe_15();
   cmovnbe_16();
   cmovnc_5();
   cmovnc_6();
   cmovnc_7();
   cmovnc_8();
   cmovne_5();
   cmovne_6();
   cmovne_7();
   cmovne_8();
   cmovng_17();
   cmovng_18();
   cmovng_19();
   cmovng_20();
   cmovng_21();
   cmovng_22();
   cmovng_23();
   cmovng_24();
   cmovng_25();
   cmovng_26();
   cmovng_27();
   cmovng_28();
   cmovng_29();
   cmovng_30();
   cmovng_31();
   cmovng_32();
   cmovnge_9();
   cmovnge_10();
   cmovnge_11();
   cmovnge_12();
   cmovnge_13();
   cmovnge_14();
   cmovnge_15();
   cmovnge_16();
   cmovnl_9();
   cmovnl_10();
   cmovnl_11();
   cmovnl_12();
   cmovnl_13();
   cmovnl_14();
   cmovnl_15();
   cmovnl_16();
   cmovnle_17();
   cmovnle_18();
   cmovnle_19();
   cmovnle_20();
   cmovnle_21();
   cmovnle_22();
   cmovnle_23();
   cmovnle_24();
   cmovnle_25();
   cmovnle_26();
   cmovnle_27();
   cmovnle_28();
   cmovnle_29();
   cmovnle_30();
   cmovnle_31();
   cmovnle_32();
   cmovno_5();
   cmovno_6();
   cmovno_7();
   cmovno_8();
   cmovnp_5();
   cmovnp_6();
   cmovnp_7();
   cmovnp_8();
   cmovns_5();
   cmovns_6();
   cmovns_7();
   cmovns_8();
   cmovnz_5();
   cmovnz_6();
   cmovnz_7();
   cmovnz_8();
   cmovo_5();
   cmovo_6();
   cmovo_7();
   cmovo_8();
   cmovp_5();
   cmovp_6();
   cmovp_7();
   cmovp_8();
   cmovs_5();
   cmovs_6();
   cmovs_7();
   cmovs_8();
   cmovz_5();
   cmovz_6();
   cmovz_7();
   cmovz_8();

   exit(0);
}
