#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 aaa_1(void)
{
   reg8_t preset0 = { .ub = { 0x1U } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x1U &&
          result1.ub[0] == 0x00U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000000UL )
      {
         printf("aaa_1 ... ok\n");
      }
      else
      {
         printf("aaa_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x1U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x00U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000000UL);
      }
   }
   else
   {
      printf("aaa_1 ... failed\n");
   }

   return;
}

static void aaa_2(void)
{
   reg8_t preset0 = { .ub = { 0x9U } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x9U &&
          result1.ub[0] == 0x00U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000000UL )
      {
         printf("aaa_2 ... ok\n");
      }
      else
      {
         printf("aaa_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x9U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x00U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000000UL);
      }
   }
   else
   {
      printf("aaa_2 ... failed\n");
   }

   return;
}

static void aaa_3(void)
{
   reg8_t preset0 = { .ub = { 0xaU } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x0U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_3 ... ok\n");
      }
      else
      {
         printf("aaa_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x0U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_3 ... failed\n");
   }

   return;
}

static void aaa_4(void)
{
   reg8_t preset0 = { .ub = { 0xfU } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x5U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_4 ... ok\n");
      }
      else
      {
         printf("aaa_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x5U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_4 ... failed\n");
   }

   return;
}

static void aaa_5(void)
{
   reg8_t preset0 = { .ub = { 0x1U } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x7U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_5 ... ok\n");
      }
      else
      {
         printf("aaa_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x7U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_5 ... failed\n");
   }

   return;
}

static void aaa_6(void)
{
   reg8_t preset0 = { .ub = { 0x9U } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0xfU &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_6 ... ok\n");
      }
      else
      {
         printf("aaa_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0xfU);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_6 ... failed\n");
   }

   return;
}

static void aaa_7(void)
{
   reg8_t preset0 = { .ub = { 0xaU } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x0U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_7 ... ok\n");
      }
      else
      {
         printf("aaa_7 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x0U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_7 ... failed\n");
   }

   return;
}

static void aaa_8(void)
{
   reg8_t preset0 = { .ub = { 0xfU } };
   reg8_t preset1 = { .ub = { 0x0U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aaa\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x5U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aaa_8 ... ok\n");
      }
      else
      {
         printf("aaa_8 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x5U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aaa_8 ... failed\n");
   }

   return;
}

static void aad_1(void)
{
   reg8_t preset0 = { .ub = { 37U } };
   reg8_t preset1 = { .ub = { 2U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%ah\n"
         "aad\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 57U &&
          result1.ub[0] == 0U )
      {
         printf("aad_1 ... ok\n");
      }
      else
      {
         printf("aad_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 57U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0U);
      }
   }
   else
   {
      printf("aad_1 ... failed\n");
   }

   return;
}

static void aad_2(void)
{
   reg8_t preset0 = { .ub = { 73U } };
   reg8_t preset1 = { .ub = { 2U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%ah\n"
         "aad\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 93U &&
          result1.ub[0] == 0U )
      {
         printf("aad_2 ... ok\n");
      }
      else
      {
         printf("aad_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 93U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0U);
      }
   }
   else
   {
      printf("aad_2 ... failed\n");
   }

   return;
}

static void aam_1(void)
{
   reg8_t preset0 = { .ub = { 37U } };
   reg8_t preset1 = { .ub = { 0U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%ah\n"
         "aam\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 7U &&
          result1.ub[0] == 3U )
      {
         printf("aam_1 ... ok\n");
      }
      else
      {
         printf("aam_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 7U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 3U);
      }
   }
   else
   {
      printf("aam_1 ... failed\n");
   }

   return;
}

static void aam_2(void)
{
   reg8_t preset0 = { .ub = { 73U } };
   reg8_t preset1 = { .ub = { 0U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%ah\n"
         "aam\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 3U &&
          result1.ub[0] == 7U )
      {
         printf("aam_2 ... ok\n");
      }
      else
      {
         printf("aam_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 3U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 7U);
      }
   }
   else
   {
      printf("aam_2 ... failed\n");
   }

   return;
}

static void aas_1(void)
{
   reg8_t preset0 = { .ub = { 0x1U } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x1U &&
          result1.ub[0] == 0x02U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000000UL )
      {
         printf("aas_1 ... ok\n");
      }
      else
      {
         printf("aas_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x1U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x02U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000000UL);
      }
   }
   else
   {
      printf("aas_1 ... failed\n");
   }

   return;
}

static void aas_2(void)
{
   reg8_t preset0 = { .ub = { 0x9U } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x9U &&
          result1.ub[0] == 0x02U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000000UL )
      {
         printf("aas_2 ... ok\n");
      }
      else
      {
         printf("aas_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x9U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x02U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000000UL);
      }
   }
   else
   {
      printf("aas_2 ... failed\n");
   }

   return;
}

static void aas_3(void)
{
   reg8_t preset0 = { .ub = { 0xaU } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x4U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_3 ... ok\n");
      }
      else
      {
         printf("aas_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x4U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_3 ... failed\n");
   }

   return;
}

static void aas_4(void)
{
   reg8_t preset0 = { .ub = { 0xfU } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x9U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_4 ... ok\n");
      }
      else
      {
         printf("aas_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x9U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_4 ... failed\n");
   }

   return;
}

static void aas_5(void)
{
   reg8_t preset0 = { .ub = { 0x1U } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0xbU &&
          result1.ub[0] == 0x00U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_5 ... ok\n");
      }
      else
      {
         printf("aas_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0xbU);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x00U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_5 ... failed\n");
   }

   return;
}

static void aas_6(void)
{
   reg8_t preset0 = { .ub = { 0x9U } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x3U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_6 ... ok\n");
      }
      else
      {
         printf("aas_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x3U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_6 ... failed\n");
   }

   return;
}

static void aas_7(void)
{
   reg8_t preset0 = { .ub = { 0xaU } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x4U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_7 ... ok\n");
      }
      else
      {
         printf("aas_7 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x4U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_7 ... failed\n");
   }

   return;
}

static void aas_8(void)
{
   reg8_t preset0 = { .ub = { 0xfU } };
   reg8_t preset1 = { .ub = { 0x2U } };
   reg8_t result0;
   reg8_t result1;
   reg32_t result2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movb %1, %%al\n"
         "movb %2, %%ah\n"
         "pushfl\n"
         "andl $0xffffffee, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "aas\n"
         "movb %%al, %3\n"
         "movb %%ah, %4\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %5\n"
         : "=m" (result2)
         : "m" (preset0), "m" (preset1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "ah"
      );

      if (result0.ub[0] == 0x9U &&
          result1.ub[0] == 0x01U &&
          (result2.ud[0] & 0x00000011UL) == 0x00000011UL )
      {
         printf("aas_8 ... ok\n");
      }
      else
      {
         printf("aas_8 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x9U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 0x01U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000011UL, result2.ud[0] & 0x00000011UL, 0x00000011UL);
      }
   }
   else
   {
      printf("aas_8 ... failed\n");
   }

   return;
}

static void adcb_1(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "adcb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void adcb_2(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "adcb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void adcb_3(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "adcb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void adcb_4(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "adcb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void adcb_5(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "adcb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void adcb_6(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "adcb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void adcb_7(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void adcb_8(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void adcb_9(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void adcb_10(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void adcb_11(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void adcb_12(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void adcw_1(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_2(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_3(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_4(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_5(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_6(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_7(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "adcw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void adcw_8(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "adcw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void adcw_9(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_10(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_11(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void adcw_12(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void adcw_13(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcw_14(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void adcl_1(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_2(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_3(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_4(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_5(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_6(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void adcl_7(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "adcl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void adcl_8(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "adcl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

static void addb_1(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "addb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void addb_2(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "addb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void addb_3(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "addb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void addb_4(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "addb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

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

   return;
}

static void addb_5(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "addb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

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

   return;
}

static void addb_6(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "addb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void addw_1(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "addw $12, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void addw_2(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "addw $1234, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void addw_3(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%bx\n"
         "addw $1234, %%bx\n"
         "movw %%bx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void addw_4(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "addw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void addw_5(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "addw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

static void addw_6(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "addw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void addw_7(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "addw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void addl_1(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "addl $12, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void addl_2(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "addl $12345678, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void addl_3(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%ebx\n"
         "addl $12345678, %%ebx\n"
         "movl %%ebx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void addl_4(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "addl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "addl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "addl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "addl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void andb_1(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "andb $0x34, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void andb_2(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "andb $0x34, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void andb_3(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "andb $0x34, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void andb_4(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "andb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

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

   return;
}

static void andb_5(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "andb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

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

   return;
}

static void andb_6(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "andb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void andw_1(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "andw $0x31, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void andw_2(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "andw $0x4231, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void andw_3(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%bx\n"
         "andw $0x4231, %%bx\n"
         "movw %%bx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void andw_4(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "andw $0x4231, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "andw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "andw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "andw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void andl_1(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "andl $0x31, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void andl_2(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "andl $0x86427531, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void andl_3(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%ebx\n"
         "andl $0x86427531, %%ebx\n"
         "movl %%ebx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void andl_4(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "andl $0x86427531, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void andl_5(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "andl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void andl_6(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "andl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void andl_7(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "andl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "bsfw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "bsfw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "bsfl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "bsfl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "bsrw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "bsrw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "bsrl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "bsrl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void bswapl_1(void)
{
   reg32_t arg0 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "bswapl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void btw_1(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btw_1 ... ok\n");
      }
      else
      {
         printf("btw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btw_1 ... failed\n");
   }

   return;
}

static void btw_2(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btw_2 ... ok\n");
      }
      else
      {
         printf("btw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btw_2 ... failed\n");
   }

   return;
}

static void btw_3(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btw $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btw_3 ... ok\n");
      }
      else
      {
         printf("btw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btw_3 ... failed\n");
   }

   return;
}

static void btw_4(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btw $12, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btw_4 ... ok\n");
      }
      else
      {
         printf("btw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btw_4 ... failed\n");
   }

   return;
}

static void btw_5(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btw_5 ... ok\n");
      }
      else
      {
         printf("btw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btw_5 ... failed\n");
   }

   return;
}

static void btw_6(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btw_6 ... ok\n");
      }
      else
      {
         printf("btw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btw_6 ... failed\n");
   }

   return;
}

static void btw_7(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btw_7 ... ok\n");
      }
      else
      {
         printf("btw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btw_7 ... failed\n");
   }

   return;
}

static void btw_8(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btw_8 ... ok\n");
      }
      else
      {
         printf("btw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btw_8 ... failed\n");
   }

   return;
}

static void btl_1(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btl_1 ... ok\n");
      }
      else
      {
         printf("btl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btl_1 ... failed\n");
   }

   return;
}

static void btl_2(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btl_2 ... ok\n");
      }
      else
      {
         printf("btl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btl_2 ... failed\n");
   }

   return;
}

static void btl_3(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btl $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btl_3 ... ok\n");
      }
      else
      {
         printf("btl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btl_3 ... failed\n");
   }

   return;
}

static void btl_4(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btl $24, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btl_4 ... ok\n");
      }
      else
      {
         printf("btl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btl_4 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btl_5 ... ok\n");
      }
      else
      {
         printf("btl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btl_5 ... failed\n");
   }

   return;
}

static void btl_6(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btl_6 ... ok\n");
      }
      else
      {
         printf("btl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btl_6 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btl_7 ... ok\n");
      }
      else
      {
         printf("btl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btl_7 ... failed\n");
   }

   return;
}

static void btl_8(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btl_8 ... ok\n");
      }
      else
      {
         printf("btl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btl_8 ... failed\n");
   }

   return;
}

static void btcw_1(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcw_1 ... ok\n");
      }
      else
      {
         printf("btcw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcw_1 ... failed\n");
   }

   return;
}

static void btcw_2(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcw_2 ... ok\n");
      }
      else
      {
         printf("btcw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcw_2 ... failed\n");
   }

   return;
}

static void btcw_3(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btcw $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcw_3 ... ok\n");
      }
      else
      {
         printf("btcw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcw_3 ... failed\n");
   }

   return;
}

static void btcw_4(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btcw $12, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcw_4 ... ok\n");
      }
      else
      {
         printf("btcw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcw_4 ... failed\n");
   }

   return;
}

static void btcw_5(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcw_5 ... ok\n");
      }
      else
      {
         printf("btcw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcw_5 ... failed\n");
   }

   return;
}

static void btcw_6(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcw_6 ... ok\n");
      }
      else
      {
         printf("btcw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcw_6 ... failed\n");
   }

   return;
}

static void btcw_7(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcw_7 ... ok\n");
      }
      else
      {
         printf("btcw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcw_7 ... failed\n");
   }

   return;
}

static void btcw_8(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcw_8 ... ok\n");
      }
      else
      {
         printf("btcw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcw_8 ... failed\n");
   }

   return;
}

static void btcl_1(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcl_1 ... ok\n");
      }
      else
      {
         printf("btcl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcl_1 ... failed\n");
   }

   return;
}

static void btcl_2(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcl_2 ... ok\n");
      }
      else
      {
         printf("btcl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcl_2 ... failed\n");
   }

   return;
}

static void btcl_3(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btcl $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcl_3 ... ok\n");
      }
      else
      {
         printf("btcl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcl_3 ... failed\n");
   }

   return;
}

static void btcl_4(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btcl $24, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcl_4 ... ok\n");
      }
      else
      {
         printf("btcl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcl_4 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcl_5 ... ok\n");
      }
      else
      {
         printf("btcl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcl_5 ... failed\n");
   }

   return;
}

static void btcl_6(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcl_6 ... ok\n");
      }
      else
      {
         printf("btcl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcl_6 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btcl_7 ... ok\n");
      }
      else
      {
         printf("btcl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btcl_7 ... failed\n");
   }

   return;
}

static void btcl_8(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btcl_8 ... ok\n");
      }
      else
      {
         printf("btcl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btcl_8 ... failed\n");
   }

   return;
}

static void btrw_1(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrw_1 ... ok\n");
      }
      else
      {
         printf("btrw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrw_1 ... failed\n");
   }

   return;
}

static void btrw_2(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrw_2 ... ok\n");
      }
      else
      {
         printf("btrw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrw_2 ... failed\n");
   }

   return;
}

static void btrw_3(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btrw $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrw_3 ... ok\n");
      }
      else
      {
         printf("btrw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrw_3 ... failed\n");
   }

   return;
}

static void btrw_4(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btrw $12, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrw_4 ... ok\n");
      }
      else
      {
         printf("btrw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrw_4 ... failed\n");
   }

   return;
}

static void btrw_5(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrw_5 ... ok\n");
      }
      else
      {
         printf("btrw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrw_5 ... failed\n");
   }

   return;
}

static void btrw_6(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrw_6 ... ok\n");
      }
      else
      {
         printf("btrw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrw_6 ... failed\n");
   }

   return;
}

static void btrw_7(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4230 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrw_7 ... ok\n");
      }
      else
      {
         printf("btrw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4230);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrw_7 ... failed\n");
   }

   return;
}

static void btrw_8(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrw_8 ... ok\n");
      }
      else
      {
         printf("btrw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrw_8 ... failed\n");
   }

   return;
}

static void btrl_1(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrl_1 ... ok\n");
      }
      else
      {
         printf("btrl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrl_1 ... failed\n");
   }

   return;
}

static void btrl_2(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrl_2 ... ok\n");
      }
      else
      {
         printf("btrl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrl_2 ... failed\n");
   }

   return;
}

static void btrl_3(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btrl $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrl_3 ... ok\n");
      }
      else
      {
         printf("btrl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrl_3 ... failed\n");
   }

   return;
}

static void btrl_4(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btrl $24, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrl_4 ... ok\n");
      }
      else
      {
         printf("btrl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrl_4 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrl_5 ... ok\n");
      }
      else
      {
         printf("btrl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrl_5 ... failed\n");
   }

   return;
}

static void btrl_6(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrl_6 ... ok\n");
      }
      else
      {
         printf("btrl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrl_6 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427530UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btrl_7 ... ok\n");
      }
      else
      {
         printf("btrl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427530UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btrl_7 ... failed\n");
   }

   return;
}

static void btrl_8(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btrl_8 ... ok\n");
      }
      else
      {
         printf("btrl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btrl_8 ... failed\n");
   }

   return;
}

static void btsw_1(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsw_1 ... ok\n");
      }
      else
      {
         printf("btsw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsw_1 ... failed\n");
   }

   return;
}

static void btsw_2(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsw_2 ... ok\n");
      }
      else
      {
         printf("btsw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsw_2 ... failed\n");
   }

   return;
}

static void btsw_3(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btsw $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsw_3 ... ok\n");
      }
      else
      {
         printf("btsw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsw_3 ... failed\n");
   }

   return;
}

static void btsw_4(void)
{
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btsw $12, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsw_4 ... ok\n");
      }
      else
      {
         printf("btsw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsw_4 ... failed\n");
   }

   return;
}

static void btsw_5(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsw_5 ... ok\n");
      }
      else
      {
         printf("btsw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsw_5 ... failed\n");
   }

   return;
}

static void btsw_6(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsw_6 ... ok\n");
      }
      else
      {
         printf("btsw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsw_6 ... failed\n");
   }

   return;
}

static void btsw_7(void)
{
   reg16_t arg0 = { .uw = { 0 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsw_7 ... ok\n");
      }
      else
      {
         printf("btsw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsw_7 ... failed\n");
   }

   return;
}

static void btsw_8(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 0x4231 } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x5231 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsw_8 ... ok\n");
      }
      else
      {
         printf("btsw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5231);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsw_8 ... failed\n");
   }

   return;
}

static void btsl_1(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsl_1 ... ok\n");
      }
      else
      {
         printf("btsl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsl_1 ... failed\n");
   }

   return;
}

static void btsl_2(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsl_2 ... ok\n");
      }
      else
      {
         printf("btsl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsl_2 ... failed\n");
   }

   return;
}

static void btsl_3(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "btsl $0, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsl_3 ... ok\n");
      }
      else
      {
         printf("btsl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsl_3 ... failed\n");
   }

   return;
}

static void btsl_4(void)
{
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "btsl $24, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsl_4 ... ok\n");
      }
      else
      {
         printf("btsl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsl_4 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsl_5 ... ok\n");
      }
      else
      {
         printf("btsl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsl_5 ... failed\n");
   }

   return;
}

static void btsl_6(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsl_6 ... ok\n");
      }
      else
      {
         printf("btsl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsl_6 ... failed\n");
   }

   return;
}

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

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

      if (result0.ud[0] == 0x86427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("btsl_7 ... ok\n");
      }
      else
      {
         printf("btsl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x86427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("btsl_7 ... failed\n");
   }

   return;
}

static void btsl_8(void)
{
   reg32_t arg0 = { .ud = { 24UL } };
   reg32_t arg1 = { .ud = { 0x86427531UL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x87427531UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("btsl_8 ... ok\n");
      }
      else
      {
         printf("btsl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x87427531UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("btsl_8 ... failed\n");
   }

   return;
}

static void cbw_1(void)
{
   reg8_t preset0 = { .sb = { 123 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "cbw\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.sw[0] == 123 )
      {
         printf("cbw_1 ... ok\n");
      }
      else
      {
         printf("cbw_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], 123);
      }
   }
   else
   {
      printf("cbw_1 ... failed\n");
   }

   return;
}

static void cbw_2(void)
{
   reg8_t preset0 = { .sb = { -123 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "cbw\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.sw[0] == -123 )
      {
         printf("cbw_2 ... ok\n");
      }
      else
      {
         printf("cbw_2 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -123);
      }
   }
   else
   {
      printf("cbw_2 ... failed\n");
   }

   return;
}

static void cdq_1(void)
{
   reg32_t preset0 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "cdq\n"
         "movl %%edx, %1\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x00000000UL &&
          result1.ud[0] == 0x12345678UL )
      {
         printf("cdq_1 ... ok\n");
      }
      else
      {
         printf("cdq_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00000000UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 0x12345678UL);
      }
   }
   else
   {
      printf("cdq_1 ... failed\n");
   }

   return;
}

static void cdq_2(void)
{
   reg32_t preset0 = { .ud = { 0xfedcba98UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "cdq\n"
         "movl %%edx, %1\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0xffffffffUL &&
          result1.ud[0] == 0xfedcba98UL )
      {
         printf("cdq_2 ... ok\n");
      }
      else
      {
         printf("cdq_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xffffffffUL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 0xfedcba98UL);
      }
   }
   else
   {
      printf("cdq_2 ... failed\n");
   }

   return;
}

static void clc_1(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "clc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("clc_1 ... ok\n");
      }
      else
      {
         printf("clc_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("clc_1 ... failed\n");
   }

   return;
}

static void clc_2(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "clc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("clc_2 ... ok\n");
      }
      else
      {
         printf("clc_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("clc_2 ... failed\n");
   }

   return;
}

static void cld_1(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffbff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cld\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000400UL) == 0x00000000UL )
      {
         printf("cld_1 ... ok\n");
      }
      else
      {
         printf("cld_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000400UL, result0.ud[0] & 0x00000400UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cld_1 ... failed\n");
   }

   return;
}

static void cld_2(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffbff, (%%esp)\n"
         "orl $0x00000400, (%%esp)\n"
         "popfl\n"
         "cld\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000400UL) == 0x00000000UL )
      {
         printf("cld_2 ... ok\n");
      }
      else
      {
         printf("cld_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000400UL, result0.ud[0] & 0x00000400UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cld_2 ... failed\n");
   }

   return;
}

static void cmc_1(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("cmc_1 ... ok\n");
      }
      else
      {
         printf("cmc_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("cmc_1 ... failed\n");
   }

   return;
}

static void cmc_2(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "cmc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("cmc_2 ... ok\n");
      }
      else
      {
         printf("cmc_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmc_2 ... failed\n");
   }

   return;
}

static void cmpb_1(void)
{
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $3, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_1 ... ok\n");
      }
      else
      {
         printf("cmpb_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_1 ... failed\n");
   }

   return;
}

static void cmpb_2(void)
{
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb $2, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_2 ... ok\n");
      }
      else
      {
         printf("cmpb_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_2 ... failed\n");
   }

   return;
}

static void cmpb_3(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_3 ... ok\n");
      }
      else
      {
         printf("cmpb_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_3 ... failed\n");
   }

   return;
}

static void cmpb_4(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_4 ... ok\n");
      }
      else
      {
         printf("cmpb_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_4 ... failed\n");
   }

   return;
}

static void cmpb_5(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $34, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_5 ... ok\n");
      }
      else
      {
         printf("cmpb_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_5 ... failed\n");
   }

   return;
}

static void cmpb_6(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_6 ... ok\n");
      }
      else
      {
         printf("cmpb_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_6 ... failed\n");
   }

   return;
}

static void cmpb_7(void)
{
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $100, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_7 ... ok\n");
      }
      else
      {
         printf("cmpb_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_7 ... failed\n");
   }

   return;
}

static void cmpb_8(void)
{
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $50, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_8 ... ok\n");
      }
      else
      {
         printf("cmpb_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_8 ... failed\n");
   }

   return;
}

static void cmpb_9(void)
{
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $-50, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_9 ... ok\n");
      }
      else
      {
         printf("cmpb_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_9 ... failed\n");
   }

   return;
}

static void cmpb_10(void)
{
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $-100, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_10 ... ok\n");
      }
      else
      {
         printf("cmpb_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_10 ... failed\n");
   }

   return;
}

static void cmpb_11(void)
{
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $3, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_11 ... ok\n");
      }
      else
      {
         printf("cmpb_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_11 ... failed\n");
   }

   return;
}

static void cmpb_12(void)
{
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb $2, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_12 ... ok\n");
      }
      else
      {
         printf("cmpb_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_12 ... failed\n");
   }

   return;
}

static void cmpb_13(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_13 ... ok\n");
      }
      else
      {
         printf("cmpb_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_13 ... failed\n");
   }

   return;
}

static void cmpb_14(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_14 ... ok\n");
      }
      else
      {
         printf("cmpb_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_14 ... failed\n");
   }

   return;
}

static void cmpb_15(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $34, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_15 ... ok\n");
      }
      else
      {
         printf("cmpb_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_15 ... failed\n");
   }

   return;
}

static void cmpb_16(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_16 ... ok\n");
      }
      else
      {
         printf("cmpb_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_16 ... failed\n");
   }

   return;
}

static void cmpb_17(void)
{
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $100, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_17 ... ok\n");
      }
      else
      {
         printf("cmpb_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_17 ... failed\n");
   }

   return;
}

static void cmpb_18(void)
{
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $50, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_18 ... ok\n");
      }
      else
      {
         printf("cmpb_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_18 ... failed\n");
   }

   return;
}

static void cmpb_19(void)
{
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $-50, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_19 ... ok\n");
      }
      else
      {
         printf("cmpb_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_19 ... failed\n");
   }

   return;
}

static void cmpb_20(void)
{
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $-100, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_20 ... ok\n");
      }
      else
      {
         printf("cmpb_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_20 ... failed\n");
   }

   return;
}

static void cmpb_21(void)
{
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $3, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_21 ... ok\n");
      }
      else
      {
         printf("cmpb_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_21 ... failed\n");
   }

   return;
}

static void cmpb_22(void)
{
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb $2, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_22 ... ok\n");
      }
      else
      {
         printf("cmpb_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_22 ... failed\n");
   }

   return;
}

static void cmpb_23(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_23 ... ok\n");
      }
      else
      {
         printf("cmpb_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_23 ... failed\n");
   }

   return;
}

static void cmpb_24(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_24 ... ok\n");
      }
      else
      {
         printf("cmpb_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_24 ... failed\n");
   }

   return;
}

static void cmpb_25(void)
{
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $34, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_25 ... ok\n");
      }
      else
      {
         printf("cmpb_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_25 ... failed\n");
   }

   return;
}

static void cmpb_26(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_26 ... ok\n");
      }
      else
      {
         printf("cmpb_26 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_26 ... failed\n");
   }

   return;
}

static void cmpb_27(void)
{
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_27 ... ok\n");
      }
      else
      {
         printf("cmpb_27 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_27 ... failed\n");
   }

   return;
}

static void cmpb_28(void)
{
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_28 ... ok\n");
      }
      else
      {
         printf("cmpb_28 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_28 ... failed\n");
   }

   return;
}

static void cmpb_29(void)
{
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpb $-50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_29 ... ok\n");
      }
      else
      {
         printf("cmpb_29 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_29 ... failed\n");
   }

   return;
}

static void cmpb_30(void)
{
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb $-100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_30 ... ok\n");
      }
      else
      {
         printf("cmpb_30 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_30 ... failed\n");
   }

   return;
}

static void cmpb_31(void)
{
   reg8_t arg0 = { .ub = { 3U } };
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_31 ... ok\n");
      }
      else
      {
         printf("cmpb_31 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_31 ... failed\n");
   }

   return;
}

static void cmpb_32(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_32 ... ok\n");
      }
      else
      {
         printf("cmpb_32 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_32 ... failed\n");
   }

   return;
}

static void cmpb_33(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_33 ... ok\n");
      }
      else
      {
         printf("cmpb_33 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_33 ... failed\n");
   }

   return;
}

static void cmpb_34(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_34 ... ok\n");
      }
      else
      {
         printf("cmpb_34 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_34 ... failed\n");
   }

   return;
}

static void cmpb_35(void)
{
   reg8_t arg0 = { .ub = { 34U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_35 ... ok\n");
      }
      else
      {
         printf("cmpb_35 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_35 ... failed\n");
   }

   return;
}

static void cmpb_36(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_36 ... ok\n");
      }
      else
      {
         printf("cmpb_36 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_36 ... failed\n");
   }

   return;
}

static void cmpb_37(void)
{
   reg8_t arg0 = { .ub = { 100U } };
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_37 ... ok\n");
      }
      else
      {
         printf("cmpb_37 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_37 ... failed\n");
   }

   return;
}

static void cmpb_38(void)
{
   reg8_t arg0 = { .ub = { 50U } };
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_38 ... ok\n");
      }
      else
      {
         printf("cmpb_38 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_38 ... failed\n");
   }

   return;
}

static void cmpb_39(void)
{
   reg8_t arg0 = { .sb = { -50 } };
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_39 ... ok\n");
      }
      else
      {
         printf("cmpb_39 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_39 ... failed\n");
   }

   return;
}

static void cmpb_40(void)
{
   reg8_t arg0 = { .sb = { -100 } };
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_40 ... ok\n");
      }
      else
      {
         printf("cmpb_40 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_40 ... failed\n");
   }

   return;
}

static void cmpb_41(void)
{
   reg8_t arg0 = { .ub = { 3U } };
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_41 ... ok\n");
      }
      else
      {
         printf("cmpb_41 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_41 ... failed\n");
   }

   return;
}

static void cmpb_42(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_42 ... ok\n");
      }
      else
      {
         printf("cmpb_42 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_42 ... failed\n");
   }

   return;
}

static void cmpb_43(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_43 ... ok\n");
      }
      else
      {
         printf("cmpb_43 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_43 ... failed\n");
   }

   return;
}

static void cmpb_44(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_44 ... ok\n");
      }
      else
      {
         printf("cmpb_44 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_44 ... failed\n");
   }

   return;
}

static void cmpb_45(void)
{
   reg8_t arg0 = { .ub = { 34U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_45 ... ok\n");
      }
      else
      {
         printf("cmpb_45 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_45 ... failed\n");
   }

   return;
}

static void cmpb_46(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_46 ... ok\n");
      }
      else
      {
         printf("cmpb_46 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_46 ... failed\n");
   }

   return;
}

static void cmpb_47(void)
{
   reg8_t arg0 = { .ub = { 100U } };
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_47 ... ok\n");
      }
      else
      {
         printf("cmpb_47 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_47 ... failed\n");
   }

   return;
}

static void cmpb_48(void)
{
   reg8_t arg0 = { .ub = { 50U } };
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_48 ... ok\n");
      }
      else
      {
         printf("cmpb_48 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_48 ... failed\n");
   }

   return;
}

static void cmpb_49(void)
{
   reg8_t arg0 = { .sb = { -50 } };
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_49 ... ok\n");
      }
      else
      {
         printf("cmpb_49 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_49 ... failed\n");
   }

   return;
}

static void cmpb_50(void)
{
   reg8_t arg0 = { .sb = { -100 } };
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_50 ... ok\n");
      }
      else
      {
         printf("cmpb_50 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_50 ... failed\n");
   }

   return;
}

static void cmpb_51(void)
{
   reg8_t arg0 = { .ub = { 3U } };
   reg8_t arg1 = { .ub = { 2U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpb_51 ... ok\n");
      }
      else
      {
         printf("cmpb_51 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpb_51 ... failed\n");
   }

   return;
}

static void cmpb_52(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 3U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpb_52 ... ok\n");
      }
      else
      {
         printf("cmpb_52 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_52 ... failed\n");
   }

   return;
}

static void cmpb_53(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpb_53 ... ok\n");
      }
      else
      {
         printf("cmpb_53 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpb_53 ... failed\n");
   }

   return;
}

static void cmpb_54(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpb_54 ... ok\n");
      }
      else
      {
         printf("cmpb_54 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_54 ... failed\n");
   }

   return;
}

static void cmpb_55(void)
{
   reg8_t arg0 = { .ub = { 34U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpb_55 ... ok\n");
      }
      else
      {
         printf("cmpb_55 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpb_55 ... failed\n");
   }

   return;
}

static void cmpb_56(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpb %1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpb_56 ... ok\n");
      }
      else
      {
         printf("cmpb_56 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_56 ... failed\n");
   }

   return;
}

static void cmpb_57(void)
{
   reg8_t arg0 = { .ub = { 100U } };
   reg8_t arg1 = { .sb = { -100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_57 ... ok\n");
      }
      else
      {
         printf("cmpb_57 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_57 ... failed\n");
   }

   return;
}

static void cmpb_58(void)
{
   reg8_t arg0 = { .ub = { 50U } };
   reg8_t arg1 = { .sb = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_58 ... ok\n");
      }
      else
      {
         printf("cmpb_58 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_58 ... failed\n");
   }

   return;
}

static void cmpb_59(void)
{
   reg8_t arg0 = { .sb = { -50 } };
   reg8_t arg1 = { .sb = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpb_59 ... ok\n");
      }
      else
      {
         printf("cmpb_59 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpb_59 ... failed\n");
   }

   return;
}

static void cmpb_60(void)
{
   reg8_t arg0 = { .sb = { -100 } };
   reg8_t arg1 = { .sb = { 100 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpb_60 ... ok\n");
      }
      else
      {
         printf("cmpb_60 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpb_60 ... failed\n");
   }

   return;
}

static void cmpw_1(void)
{
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_1 ... ok\n");
      }
      else
      {
         printf("cmpw_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_1 ... failed\n");
   }

   return;
}

static void cmpw_2(void)
{
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw $2, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_2 ... ok\n");
      }
      else
      {
         printf("cmpw_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_2 ... failed\n");
   }

   return;
}

static void cmpw_3(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_3 ... ok\n");
      }
      else
      {
         printf("cmpw_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_3 ... failed\n");
   }

   return;
}

static void cmpw_4(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_4 ... ok\n");
      }
      else
      {
         printf("cmpw_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_4 ... failed\n");
   }

   return;
}

static void cmpw_5(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $34, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_5 ... ok\n");
      }
      else
      {
         printf("cmpw_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_5 ... failed\n");
   }

   return;
}

static void cmpw_6(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_6 ... ok\n");
      }
      else
      {
         printf("cmpw_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_6 ... failed\n");
   }

   return;
}

static void cmpw_7(void)
{
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_7 ... ok\n");
      }
      else
      {
         printf("cmpw_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_7 ... failed\n");
   }

   return;
}

static void cmpw_8(void)
{
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_8 ... ok\n");
      }
      else
      {
         printf("cmpw_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_8 ... failed\n");
   }

   return;
}

static void cmpw_9(void)
{
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_9 ... ok\n");
      }
      else
      {
         printf("cmpw_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_9 ... failed\n");
   }

   return;
}

static void cmpw_10(void)
{
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_10 ... ok\n");
      }
      else
      {
         printf("cmpw_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_10 ... failed\n");
   }

   return;
}

static void cmpw_11(void)
{
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $3, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_11 ... ok\n");
      }
      else
      {
         printf("cmpw_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_11 ... failed\n");
   }

   return;
}

static void cmpw_12(void)
{
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw $2, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_12 ... ok\n");
      }
      else
      {
         printf("cmpw_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_12 ... failed\n");
   }

   return;
}

static void cmpw_13(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_13 ... ok\n");
      }
      else
      {
         printf("cmpw_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_13 ... failed\n");
   }

   return;
}

static void cmpw_14(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_14 ... ok\n");
      }
      else
      {
         printf("cmpw_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_14 ... failed\n");
   }

   return;
}

static void cmpw_15(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $34, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_15 ... ok\n");
      }
      else
      {
         printf("cmpw_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_15 ... failed\n");
   }

   return;
}

static void cmpw_16(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_16 ... ok\n");
      }
      else
      {
         printf("cmpw_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_16 ... failed\n");
   }

   return;
}

static void cmpw_17(void)
{
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_17 ... ok\n");
      }
      else
      {
         printf("cmpw_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_17 ... failed\n");
   }

   return;
}

static void cmpw_18(void)
{
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpw $50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_18 ... ok\n");
      }
      else
      {
         printf("cmpw_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_18 ... failed\n");
   }

   return;
}

static void cmpw_19(void)
{
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpw $-50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_19 ... ok\n");
      }
      else
      {
         printf("cmpw_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_19 ... failed\n");
   }

   return;
}

static void cmpw_20(void)
{
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $-100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_20 ... ok\n");
      }
      else
      {
         printf("cmpw_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_20 ... failed\n");
   }

   return;
}

static void cmpw_21(void)
{
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_21 ... ok\n");
      }
      else
      {
         printf("cmpw_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_21 ... failed\n");
   }

   return;
}

static void cmpw_22(void)
{
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw $2, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_22 ... ok\n");
      }
      else
      {
         printf("cmpw_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_22 ... failed\n");
   }

   return;
}

static void cmpw_23(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_23 ... ok\n");
      }
      else
      {
         printf("cmpw_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_23 ... failed\n");
   }

   return;
}

static void cmpw_24(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_24 ... ok\n");
      }
      else
      {
         printf("cmpw_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_24 ... failed\n");
   }

   return;
}

static void cmpw_25(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $34, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_25 ... ok\n");
      }
      else
      {
         printf("cmpw_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_25 ... failed\n");
   }

   return;
}

static void cmpw_26(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_26 ... ok\n");
      }
      else
      {
         printf("cmpw_26 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_26 ... failed\n");
   }

   return;
}

static void cmpw_27(void)
{
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_27 ... ok\n");
      }
      else
      {
         printf("cmpw_27 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_27 ... failed\n");
   }

   return;
}

static void cmpw_28(void)
{
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_28 ... ok\n");
      }
      else
      {
         printf("cmpw_28 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_28 ... failed\n");
   }

   return;
}

static void cmpw_29(void)
{
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_29 ... ok\n");
      }
      else
      {
         printf("cmpw_29 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_29 ... failed\n");
   }

   return;
}

static void cmpw_30(void)
{
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_30 ... ok\n");
      }
      else
      {
         printf("cmpw_30 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_30 ... failed\n");
   }

   return;
}

static void cmpw_31(void)
{
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_31 ... ok\n");
      }
      else
      {
         printf("cmpw_31 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_31 ... failed\n");
   }

   return;
}

static void cmpw_32(void)
{
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw $2, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_32 ... ok\n");
      }
      else
      {
         printf("cmpw_32 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_32 ... failed\n");
   }

   return;
}

static void cmpw_33(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_33 ... ok\n");
      }
      else
      {
         printf("cmpw_33 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_33 ... failed\n");
   }

   return;
}

static void cmpw_34(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_34 ... ok\n");
      }
      else
      {
         printf("cmpw_34 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_34 ... failed\n");
   }

   return;
}

static void cmpw_35(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $34, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_35 ... ok\n");
      }
      else
      {
         printf("cmpw_35 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_35 ... failed\n");
   }

   return;
}

static void cmpw_36(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_36 ... ok\n");
      }
      else
      {
         printf("cmpw_36 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_36 ... failed\n");
   }

   return;
}

static void cmpw_37(void)
{
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_37 ... ok\n");
      }
      else
      {
         printf("cmpw_37 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_37 ... failed\n");
   }

   return;
}

static void cmpw_38(void)
{
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_38 ... ok\n");
      }
      else
      {
         printf("cmpw_38 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_38 ... failed\n");
   }

   return;
}

static void cmpw_39(void)
{
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_39 ... ok\n");
      }
      else
      {
         printf("cmpw_39 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_39 ... failed\n");
   }

   return;
}

static void cmpw_40(void)
{
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_40 ... ok\n");
      }
      else
      {
         printf("cmpw_40 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_40 ... failed\n");
   }

   return;
}

static void cmpw_41(void)
{
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $3, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_41 ... ok\n");
      }
      else
      {
         printf("cmpw_41 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_41 ... failed\n");
   }

   return;
}

static void cmpw_42(void)
{
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw $2, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_42 ... ok\n");
      }
      else
      {
         printf("cmpw_42 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_42 ... failed\n");
   }

   return;
}

static void cmpw_43(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_43 ... ok\n");
      }
      else
      {
         printf("cmpw_43 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_43 ... failed\n");
   }

   return;
}

static void cmpw_44(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_44 ... ok\n");
      }
      else
      {
         printf("cmpw_44 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_44 ... failed\n");
   }

   return;
}

static void cmpw_45(void)
{
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $34, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_45 ... ok\n");
      }
      else
      {
         printf("cmpw_45 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_45 ... failed\n");
   }

   return;
}

static void cmpw_46(void)
{
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_46 ... ok\n");
      }
      else
      {
         printf("cmpw_46 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_46 ... failed\n");
   }

   return;
}

static void cmpw_47(void)
{
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_47 ... ok\n");
      }
      else
      {
         printf("cmpw_47 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_47 ... failed\n");
   }

   return;
}

static void cmpw_48(void)
{
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpw $50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_48 ... ok\n");
      }
      else
      {
         printf("cmpw_48 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_48 ... failed\n");
   }

   return;
}

static void cmpw_49(void)
{
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpw $-50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_49 ... ok\n");
      }
      else
      {
         printf("cmpw_49 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_49 ... failed\n");
   }

   return;
}

static void cmpw_50(void)
{
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw $-100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_50 ... ok\n");
      }
      else
      {
         printf("cmpw_50 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_50 ... failed\n");
   }

   return;
}

static void cmpw_51(void)
{
   reg16_t arg0 = { .uw = { 3 } };
   reg16_t arg1 = { .uw = { 2 } };
   reg32_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 $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_51 ... ok\n");
      }
      else
      {
         printf("cmpw_51 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_51 ... failed\n");
   }

   return;
}

static void cmpw_52(void)
{
   reg16_t arg0 = { .uw = { 2 } };
   reg16_t arg1 = { .uw = { 3 } };
   reg32_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 $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_52 ... ok\n");
      }
      else
      {
         printf("cmpw_52 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_52 ... failed\n");
   }

   return;
}

static void cmpw_53(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_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 $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_53 ... ok\n");
      }
      else
      {
         printf("cmpw_53 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_53 ... failed\n");
   }

   return;
}

static void cmpw_54(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_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 $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_54 ... ok\n");
      }
      else
      {
         printf("cmpw_54 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_54 ... failed\n");
   }

   return;
}

static void cmpw_55(void)
{
   reg16_t arg0 = { .uw = { 34 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_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 $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_55 ... ok\n");
      }
      else
      {
         printf("cmpw_55 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_55 ... failed\n");
   }

   return;
}

static void cmpw_56(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_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 $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_56 ... ok\n");
      }
      else
      {
         printf("cmpw_56 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_56 ... failed\n");
   }

   return;
}

static void cmpw_57(void)
{
   reg16_t arg0 = { .uw = { 100 } };
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_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"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_57 ... ok\n");
      }
      else
      {
         printf("cmpw_57 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_57 ... failed\n");
   }

   return;
}

static void cmpw_58(void)
{
   reg16_t arg0 = { .uw = { 50 } };
   reg16_t arg1 = { .sw = { -50 } };
   reg32_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"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_58 ... ok\n");
      }
      else
      {
         printf("cmpw_58 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_58 ... failed\n");
   }

   return;
}

static void cmpw_59(void)
{
   reg16_t arg0 = { .sw = { -50 } };
   reg16_t arg1 = { .sw = { 50 } };
   reg32_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"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_59 ... ok\n");
      }
      else
      {
         printf("cmpw_59 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_59 ... failed\n");
   }

   return;
}

static void cmpw_60(void)
{
   reg16_t arg0 = { .sw = { -100 } };
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_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"
         "cmpw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_60 ... ok\n");
      }
      else
      {
         printf("cmpw_60 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_60 ... failed\n");
   }

   return;
}

static void cmpw_61(void)
{
   reg16_t arg0 = { .uw = { 3 } };
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_61 ... ok\n");
      }
      else
      {
         printf("cmpw_61 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_61 ... failed\n");
   }

   return;
}

static void cmpw_62(void)
{
   reg16_t arg0 = { .uw = { 2 } };
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_62 ... ok\n");
      }
      else
      {
         printf("cmpw_62 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_62 ... failed\n");
   }

   return;
}

static void cmpw_63(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_63 ... ok\n");
      }
      else
      {
         printf("cmpw_63 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_63 ... failed\n");
   }

   return;
}

static void cmpw_64(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_64 ... ok\n");
      }
      else
      {
         printf("cmpw_64 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_64 ... failed\n");
   }

   return;
}

static void cmpw_65(void)
{
   reg16_t arg0 = { .uw = { 34 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_65 ... ok\n");
      }
      else
      {
         printf("cmpw_65 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_65 ... failed\n");
   }

   return;
}

static void cmpw_66(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_66 ... ok\n");
      }
      else
      {
         printf("cmpw_66 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_66 ... failed\n");
   }

   return;
}

static void cmpw_67(void)
{
   reg16_t arg0 = { .uw = { 100 } };
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_67 ... ok\n");
      }
      else
      {
         printf("cmpw_67 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_67 ... failed\n");
   }

   return;
}

static void cmpw_68(void)
{
   reg16_t arg0 = { .uw = { 50 } };
   reg16_t arg1 = { .sw = { -50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_68 ... ok\n");
      }
      else
      {
         printf("cmpw_68 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_68 ... failed\n");
   }

   return;
}

static void cmpw_69(void)
{
   reg16_t arg0 = { .sw = { -50 } };
   reg16_t arg1 = { .sw = { 50 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_69 ... ok\n");
      }
      else
      {
         printf("cmpw_69 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_69 ... failed\n");
   }

   return;
}

static void cmpw_70(void)
{
   reg16_t arg0 = { .sw = { -100 } };
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_70 ... ok\n");
      }
      else
      {
         printf("cmpw_70 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_70 ... failed\n");
   }

   return;
}

static void cmpw_71(void)
{
   reg16_t arg0 = { .uw = { 3 } };
   reg16_t arg1 = { .uw = { 2 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpw_71 ... ok\n");
      }
      else
      {
         printf("cmpw_71 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpw_71 ... failed\n");
   }

   return;
}

static void cmpw_72(void)
{
   reg16_t arg0 = { .uw = { 2 } };
   reg16_t arg1 = { .uw = { 3 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpw_72 ... ok\n");
      }
      else
      {
         printf("cmpw_72 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_72 ... failed\n");
   }

   return;
}

static void cmpw_73(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpw_73 ... ok\n");
      }
      else
      {
         printf("cmpw_73 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpw_73 ... failed\n");
   }

   return;
}

static void cmpw_74(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpw_74 ... ok\n");
      }
      else
      {
         printf("cmpw_74 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_74 ... failed\n");
   }

   return;
}

static void cmpw_75(void)
{
   reg16_t arg0 = { .uw = { 34 } };
   reg16_t arg1 = { .uw = { 12 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpw_75 ... ok\n");
      }
      else
      {
         printf("cmpw_75 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpw_75 ... failed\n");
   }

   return;
}

static void cmpw_76(void)
{
   reg16_t arg0 = { .uw = { 12 } };
   reg16_t arg1 = { .uw = { 34 } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpw_76 ... ok\n");
      }
      else
      {
         printf("cmpw_76 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_76 ... failed\n");
   }

   return;
}

static void cmpw_77(void)
{
   reg16_t arg0 = { .uw = { 100 } };
   reg16_t arg1 = { .sw = { -32700 } };
   reg32_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"
         "cmpw %1, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_77 ... ok\n");
      }
      else
      {
         printf("cmpw_77 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_77 ... failed\n");
   }

   return;
}

static void cmpw_78(void)
{
   reg16_t arg0 = { .uw = { 50 } };
   reg16_t arg1 = { .sw = { -50 } };
   reg32_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"
         "cmpw %1, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_78 ... ok\n");
      }
      else
      {
         printf("cmpw_78 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_78 ... failed\n");
   }

   return;
}

static void cmpw_79(void)
{
   reg16_t arg0 = { .sw = { -50 } };
   reg16_t arg1 = { .sw = { 50 } };
   reg32_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"
         "cmpw %1, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpw_79 ... ok\n");
      }
      else
      {
         printf("cmpw_79 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpw_79 ... failed\n");
   }

   return;
}

static void cmpw_80(void)
{
   reg16_t arg0 = { .sw = { -100 } };
   reg16_t arg1 = { .sw = { 32700 } };
   reg32_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"
         "cmpw %1, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpw_80 ... ok\n");
      }
      else
      {
         printf("cmpw_80 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpw_80 ... failed\n");
   }

   return;
}

static void cmpl_1(void)
{
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_1 ... ok\n");
      }
      else
      {
         printf("cmpl_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_1 ... failed\n");
   }

   return;
}

static void cmpl_2(void)
{
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl $2, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_2 ... ok\n");
      }
      else
      {
         printf("cmpl_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_2 ... failed\n");
   }

   return;
}

static void cmpl_3(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_3 ... ok\n");
      }
      else
      {
         printf("cmpl_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_3 ... failed\n");
   }

   return;
}

static void cmpl_4(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_4 ... ok\n");
      }
      else
      {
         printf("cmpl_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_4 ... failed\n");
   }

   return;
}

static void cmpl_5(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $34, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_5 ... ok\n");
      }
      else
      {
         printf("cmpl_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_5 ... failed\n");
   }

   return;
}

static void cmpl_6(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_6 ... ok\n");
      }
      else
      {
         printf("cmpl_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_6 ... failed\n");
   }

   return;
}

static void cmpl_7(void)
{
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_7 ... ok\n");
      }
      else
      {
         printf("cmpl_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_7 ... failed\n");
   }

   return;
}

static void cmpl_8(void)
{
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_8 ... ok\n");
      }
      else
      {
         printf("cmpl_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_8 ... failed\n");
   }

   return;
}

static void cmpl_9(void)
{
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $-50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_9 ... ok\n");
      }
      else
      {
         printf("cmpl_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_9 ... failed\n");
   }

   return;
}

static void cmpl_10(void)
{
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $-100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_10 ... ok\n");
      }
      else
      {
         printf("cmpl_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_10 ... failed\n");
   }

   return;
}

static void cmpl_11(void)
{
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $3, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_11 ... ok\n");
      }
      else
      {
         printf("cmpl_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_11 ... failed\n");
   }

   return;
}

static void cmpl_12(void)
{
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl $2, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_12 ... ok\n");
      }
      else
      {
         printf("cmpl_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_12 ... failed\n");
   }

   return;
}

static void cmpl_13(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_13 ... ok\n");
      }
      else
      {
         printf("cmpl_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_13 ... failed\n");
   }

   return;
}

static void cmpl_14(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_14 ... ok\n");
      }
      else
      {
         printf("cmpl_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_14 ... failed\n");
   }

   return;
}

static void cmpl_15(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $34, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_15 ... ok\n");
      }
      else
      {
         printf("cmpl_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_15 ... failed\n");
   }

   return;
}

static void cmpl_16(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_16 ... ok\n");
      }
      else
      {
         printf("cmpl_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_16 ... failed\n");
   }

   return;
}

static void cmpl_17(void)
{
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_17 ... ok\n");
      }
      else
      {
         printf("cmpl_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_17 ... failed\n");
   }

   return;
}

static void cmpl_18(void)
{
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_18 ... ok\n");
      }
      else
      {
         printf("cmpl_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_18 ... failed\n");
   }

   return;
}

static void cmpl_19(void)
{
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $-50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_19 ... ok\n");
      }
      else
      {
         printf("cmpl_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_19 ... failed\n");
   }

   return;
}

static void cmpl_20(void)
{
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $-100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_20 ... ok\n");
      }
      else
      {
         printf("cmpl_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_20 ... failed\n");
   }

   return;
}

static void cmpl_21(void)
{
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_21 ... ok\n");
      }
      else
      {
         printf("cmpl_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_21 ... failed\n");
   }

   return;
}

static void cmpl_22(void)
{
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl $2, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_22 ... ok\n");
      }
      else
      {
         printf("cmpl_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_22 ... failed\n");
   }

   return;
}

static void cmpl_23(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_23 ... ok\n");
      }
      else
      {
         printf("cmpl_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_23 ... failed\n");
   }

   return;
}

static void cmpl_24(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_24 ... ok\n");
      }
      else
      {
         printf("cmpl_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_24 ... failed\n");
   }

   return;
}

static void cmpl_25(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $34, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_25 ... ok\n");
      }
      else
      {
         printf("cmpl_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_25 ... failed\n");
   }

   return;
}

static void cmpl_26(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_26 ... ok\n");
      }
      else
      {
         printf("cmpl_26 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_26 ... failed\n");
   }

   return;
}

static void cmpl_27(void)
{
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_27 ... ok\n");
      }
      else
      {
         printf("cmpl_27 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_27 ... failed\n");
   }

   return;
}

static void cmpl_28(void)
{
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_28 ... ok\n");
      }
      else
      {
         printf("cmpl_28 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_28 ... failed\n");
   }

   return;
}

static void cmpl_29(void)
{
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $-50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_29 ... ok\n");
      }
      else
      {
         printf("cmpl_29 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_29 ... failed\n");
   }

   return;
}

static void cmpl_30(void)
{
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $-100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_30 ... ok\n");
      }
      else
      {
         printf("cmpl_30 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_30 ... failed\n");
   }

   return;
}

static void cmpl_31(void)
{
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_31 ... ok\n");
      }
      else
      {
         printf("cmpl_31 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_31 ... failed\n");
   }

   return;
}

static void cmpl_32(void)
{
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl $2, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_32 ... ok\n");
      }
      else
      {
         printf("cmpl_32 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_32 ... failed\n");
   }

   return;
}

static void cmpl_33(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_33 ... ok\n");
      }
      else
      {
         printf("cmpl_33 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_33 ... failed\n");
   }

   return;
}

static void cmpl_34(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_34 ... ok\n");
      }
      else
      {
         printf("cmpl_34 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_34 ... failed\n");
   }

   return;
}

static void cmpl_35(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $34, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_35 ... ok\n");
      }
      else
      {
         printf("cmpl_35 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_35 ... failed\n");
   }

   return;
}

static void cmpl_36(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_36 ... ok\n");
      }
      else
      {
         printf("cmpl_36 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_36 ... failed\n");
   }

   return;
}

static void cmpl_37(void)
{
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_37 ... ok\n");
      }
      else
      {
         printf("cmpl_37 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_37 ... failed\n");
   }

   return;
}

static void cmpl_38(void)
{
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_38 ... ok\n");
      }
      else
      {
         printf("cmpl_38 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_38 ... failed\n");
   }

   return;
}

static void cmpl_39(void)
{
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $-50, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_39 ... ok\n");
      }
      else
      {
         printf("cmpl_39 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_39 ... failed\n");
   }

   return;
}

static void cmpl_40(void)
{
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $-100, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_40 ... ok\n");
      }
      else
      {
         printf("cmpl_40 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_40 ... failed\n");
   }

   return;
}

static void cmpl_41(void)
{
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $3, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_41 ... ok\n");
      }
      else
      {
         printf("cmpl_41 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_41 ... failed\n");
   }

   return;
}

static void cmpl_42(void)
{
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl $2, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_42 ... ok\n");
      }
      else
      {
         printf("cmpl_42 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_42 ... failed\n");
   }

   return;
}

static void cmpl_43(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_43 ... ok\n");
      }
      else
      {
         printf("cmpl_43 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_43 ... failed\n");
   }

   return;
}

static void cmpl_44(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_44 ... ok\n");
      }
      else
      {
         printf("cmpl_44 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_44 ... failed\n");
   }

   return;
}

static void cmpl_45(void)
{
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $34, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_45 ... ok\n");
      }
      else
      {
         printf("cmpl_45 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_45 ... failed\n");
   }

   return;
}

static void cmpl_46(void)
{
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl $12, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_46 ... ok\n");
      }
      else
      {
         printf("cmpl_46 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_46 ... failed\n");
   }

   return;
}

static void cmpl_47(void)
{
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_47 ... ok\n");
      }
      else
      {
         printf("cmpl_47 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_47 ... failed\n");
   }

   return;
}

static void cmpl_48(void)
{
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_48 ... ok\n");
      }
      else
      {
         printf("cmpl_48 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_48 ... failed\n");
   }

   return;
}

static void cmpl_49(void)
{
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "cmpl $-50, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_49 ... ok\n");
      }
      else
      {
         printf("cmpl_49 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_49 ... failed\n");
   }

   return;
}

static void cmpl_50(void)
{
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl $-100, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_50 ... ok\n");
      }
      else
      {
         printf("cmpl_50 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_50 ... failed\n");
   }

   return;
}

static void cmpl_51(void)
{
   reg32_t arg0 = { .ud = { 3UL } };
   reg32_t arg1 = { .ud = { 2UL } };
   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 $0xffffffef, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_51 ... ok\n");
      }
      else
      {
         printf("cmpl_51 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_51 ... failed\n");
   }

   return;
}

static void cmpl_52(void)
{
   reg32_t arg0 = { .ud = { 2UL } };
   reg32_t arg1 = { .ud = { 3UL } };
   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 $0xffffffef, (%%esp)\n"
         "orl $0x00000010, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_52 ... ok\n");
      }
      else
      {
         printf("cmpl_52 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_52 ... failed\n");
   }

   return;
}

static void cmpl_53(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 12UL } };
   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 $0xffffffbb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_53 ... ok\n");
      }
      else
      {
         printf("cmpl_53 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_53 ... failed\n");
   }

   return;
}

static void cmpl_54(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   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 $0xffffffbb, (%%esp)\n"
         "orl $0x00000044, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_54 ... ok\n");
      }
      else
      {
         printf("cmpl_54 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_54 ... failed\n");
   }

   return;
}

static void cmpl_55(void)
{
   reg32_t arg0 = { .ud = { 34UL } };
   reg32_t arg1 = { .ud = { 12UL } };
   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 $0xffffff7e, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_55 ... ok\n");
      }
      else
      {
         printf("cmpl_55 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_55 ... failed\n");
   }

   return;
}

static void cmpl_56(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   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 $0xffffff7e, (%%esp)\n"
         "orl $0x00000081, (%%esp)\n"
         "popfl\n"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_56 ... ok\n");
      }
      else
      {
         printf("cmpl_56 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_56 ... failed\n");
   }

   return;
}

static void cmpl_57(void)
{
   reg32_t arg0 = { .ud = { 100UL } };
   reg32_t arg1 = { .sd = { -2147483600L } };
   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"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_57 ... ok\n");
      }
      else
      {
         printf("cmpl_57 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_57 ... failed\n");
   }

   return;
}

static void cmpl_58(void)
{
   reg32_t arg0 = { .ud = { 50UL } };
   reg32_t arg1 = { .sd = { -50L } };
   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"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_58 ... ok\n");
      }
      else
      {
         printf("cmpl_58 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_58 ... failed\n");
   }

   return;
}

static void cmpl_59(void)
{
   reg32_t arg0 = { .sd = { -50L } };
   reg32_t arg1 = { .sd = { 50L } };
   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"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_59 ... ok\n");
      }
      else
      {
         printf("cmpl_59 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_59 ... failed\n");
   }

   return;
}

static void cmpl_60(void)
{
   reg32_t arg0 = { .sd = { -100L } };
   reg32_t arg1 = { .sd = { 2147483600L } };
   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"
         "cmpl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_60 ... ok\n");
      }
      else
      {
         printf("cmpl_60 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_60 ... failed\n");
   }

   return;
}

static void cmpl_61(void)
{
   reg32_t arg0 = { .ud = { 3UL } };
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_61 ... ok\n");
      }
      else
      {
         printf("cmpl_61 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_61 ... failed\n");
   }

   return;
}

static void cmpl_62(void)
{
   reg32_t arg0 = { .ud = { 2UL } };
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_62 ... ok\n");
      }
      else
      {
         printf("cmpl_62 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_62 ... failed\n");
   }

   return;
}

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

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_63 ... ok\n");
      }
      else
      {
         printf("cmpl_63 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_63 ... failed\n");
   }

   return;
}

static void cmpl_64(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_64 ... ok\n");
      }
      else
      {
         printf("cmpl_64 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_64 ... failed\n");
   }

   return;
}

static void cmpl_65(void)
{
   reg32_t arg0 = { .ud = { 34UL } };
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_65 ... ok\n");
      }
      else
      {
         printf("cmpl_65 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_65 ... failed\n");
   }

   return;
}

static void cmpl_66(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_66 ... ok\n");
      }
      else
      {
         printf("cmpl_66 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_66 ... failed\n");
   }

   return;
}

static void cmpl_67(void)
{
   reg32_t arg0 = { .ud = { 100UL } };
   reg32_t arg1 = { .sd = { -2147483600L } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_67 ... ok\n");
      }
      else
      {
         printf("cmpl_67 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_67 ... failed\n");
   }

   return;
}

static void cmpl_68(void)
{
   reg32_t arg0 = { .ud = { 50UL } };
   reg32_t arg1 = { .sd = { -50L } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_68 ... ok\n");
      }
      else
      {
         printf("cmpl_68 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_68 ... failed\n");
   }

   return;
}

static void cmpl_69(void)
{
   reg32_t arg0 = { .sd = { -50L } };
   reg32_t arg1 = { .sd = { 50L } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_69 ... ok\n");
      }
      else
      {
         printf("cmpl_69 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_69 ... failed\n");
   }

   return;
}

static void cmpl_70(void)
{
   reg32_t arg0 = { .sd = { -100L } };
   reg32_t arg1 = { .sd = { 2147483600L } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_70 ... ok\n");
      }
      else
      {
         printf("cmpl_70 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_70 ... failed\n");
   }

   return;
}

static void cmpl_71(void)
{
   reg32_t arg0 = { .ud = { 3UL } };
   reg32_t arg1 = { .ud = { 2UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000010UL )
      {
         printf("cmpl_71 ... ok\n");
      }
      else
      {
         printf("cmpl_71 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000010UL);
      }
   }
   else
   {
      printf("cmpl_71 ... failed\n");
   }

   return;
}

static void cmpl_72(void)
{
   reg32_t arg0 = { .ud = { 2UL } };
   reg32_t arg1 = { .ud = { 3UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000010UL) == 0x00000000UL )
      {
         printf("cmpl_72 ... ok\n");
      }
      else
      {
         printf("cmpl_72 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000010UL, result0.ud[0] & 0x00000010UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_72 ... failed\n");
   }

   return;
}

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

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000044UL )
      {
         printf("cmpl_73 ... ok\n");
      }
      else
      {
         printf("cmpl_73 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000044UL);
      }
   }
   else
   {
      printf("cmpl_73 ... failed\n");
   }

   return;
}

static void cmpl_74(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000044UL) == 0x00000000UL )
      {
         printf("cmpl_74 ... ok\n");
      }
      else
      {
         printf("cmpl_74 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000044UL, result0.ud[0] & 0x00000044UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_74 ... failed\n");
   }

   return;
}

static void cmpl_75(void)
{
   reg32_t arg0 = { .ud = { 34UL } };
   reg32_t arg1 = { .ud = { 12UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000081UL )
      {
         printf("cmpl_75 ... ok\n");
      }
      else
      {
         printf("cmpl_75 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000081UL);
      }
   }
   else
   {
      printf("cmpl_75 ... failed\n");
   }

   return;
}

static void cmpl_76(void)
{
   reg32_t arg0 = { .ud = { 12UL } };
   reg32_t arg1 = { .ud = { 34UL } };
   reg32_t result0;
   char state[108];

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

      if ((result0.ud[0] & 0x00000081UL) == 0x00000000UL )
      {
         printf("cmpl_76 ... ok\n");
      }
      else
      {
         printf("cmpl_76 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000081UL, result0.ud[0] & 0x00000081UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_76 ... failed\n");
   }

   return;
}

static void cmpl_77(void)
{
   reg32_t arg0 = { .ud = { 100UL } };
   reg32_t arg1 = { .sd = { -2147483600L } };
   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"
         "cmpl %1, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_77 ... ok\n");
      }
      else
      {
         printf("cmpl_77 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_77 ... failed\n");
   }

   return;
}

static void cmpl_78(void)
{
   reg32_t arg0 = { .ud = { 50UL } };
   reg32_t arg1 = { .sd = { -50L } };
   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"
         "cmpl %1, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_78 ... ok\n");
      }
      else
      {
         printf("cmpl_78 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_78 ... failed\n");
   }

   return;
}

static void cmpl_79(void)
{
   reg32_t arg0 = { .sd = { -50L } };
   reg32_t arg1 = { .sd = { 50L } };
   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"
         "cmpl %1, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000000UL )
      {
         printf("cmpl_79 ... ok\n");
      }
      else
      {
         printf("cmpl_79 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000000UL);
      }
   }
   else
   {
      printf("cmpl_79 ... failed\n");
   }

   return;
}

static void cmpl_80(void)
{
   reg32_t arg0 = { .sd = { -100L } };
   reg32_t arg1 = { .sd = { 2147483600L } };
   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"
         "cmpl %1, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x00000800UL) == 0x00000800UL )
      {
         printf("cmpl_80 ... ok\n");
      }
      else
      {
         printf("cmpl_80 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000800UL, result0.ud[0] & 0x00000800UL, 0x00000800UL);
      }
   }
   else
   {
      printf("cmpl_80 ... failed\n");
   }

   return;
}

static void cmpxchgb_1(void)
{
   reg16_t preset0 = { .uw = { 12 } };
   reg8_t arg0 = { .ub = { 56U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   reg8_t result1;
   reg8_t result2;
   reg8_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movw %1, %%ax\n"
         "movb %2, %%bl\n"
         "movb %3, %%cl\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgb %%bl, %%cl\n"
         "pushfl\n"
         "popl %0\n"
         "movb %%al, %4\n"
         "movb %%bl, %5\n"
         "movb %%cl, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "ax", "bl", "cl"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.ub[0] == 12U &&
          result2.ub[0] == 56U &&
          result3.ub[0] == 56U )
      {
         printf("cmpxchgb_1 ... ok\n");
      }
      else
      {
         printf("cmpxchgb_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 12U);
         printf("  result2.ub[0] = %u (expected %u)\n", result2.ub[0], 56U);
         printf("  result3.ub[0] = %u (expected %u)\n", result3.ub[0], 56U);
      }
   }
   else
   {
      printf("cmpxchgb_1 ... failed\n");
   }

   return;
}

static void cmpxchgb_2(void)
{
   reg8_t preset0 = { .ub = { 12U } };
   reg8_t arg0 = { .ub = { 56U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   reg8_t result1;
   reg8_t result2;
   reg8_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "movb %3, %%cl\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgb %%bl, %%cl\n"
         "pushfl\n"
         "popl %0\n"
         "movb %%al, %4\n"
         "movb %%bl, %5\n"
         "movb %%cl, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "al", "bl", "cl"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.ub[0] == 34U &&
          result2.ub[0] == 56U &&
          result3.ub[0] == 34U )
      {
         printf("cmpxchgb_2 ... ok\n");
      }
      else
      {
         printf("cmpxchgb_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 34U);
         printf("  result2.ub[0] = %u (expected %u)\n", result2.ub[0], 56U);
         printf("  result3.ub[0] = %u (expected %u)\n", result3.ub[0], 34U);
      }
   }
   else
   {
      printf("cmpxchgb_2 ... failed\n");
   }

   return;
}

static void cmpxchgb_3(void)
{
   reg8_t preset0 = { .ub = { 12U } };
   reg8_t arg0 = { .ub = { 56U } };
   reg8_t arg1 = { .ub = { 12U } };
   reg32_t result0;
   reg8_t result1;
   reg8_t result2;
   reg8_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movb %2, %%al\n"
         "movb %3, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgb %%bl, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movb %%al, %5\n"
         "movb %%bl, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.ub[0] == 12U &&
          result2.ub[0] == 56U &&
          result3.ub[0] == 56U )
      {
         printf("cmpxchgb_3 ... ok\n");
      }
      else
      {
         printf("cmpxchgb_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 12U);
         printf("  result2.ub[0] = %u (expected %u)\n", result2.ub[0], 56U);
         printf("  result3.ub[0] = %u (expected %u)\n", result3.ub[0], 56U);
      }
   }
   else
   {
      printf("cmpxchgb_3 ... failed\n");
   }

   return;
}

static void cmpxchgb_4(void)
{
   reg8_t preset0 = { .ub = { 12U } };
   reg8_t arg0 = { .ub = { 56U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg32_t result0;
   reg8_t result1;
   reg8_t result2;
   reg8_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movb %2, %%al\n"
         "movb %3, %%bl\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgb %%bl, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movb %%al, %5\n"
         "movb %%bl, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.ub[0] == 34U &&
          result2.ub[0] == 56U &&
          result3.ub[0] == 34U )
      {
         printf("cmpxchgb_4 ... ok\n");
      }
      else
      {
         printf("cmpxchgb_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 34U);
         printf("  result2.ub[0] = %u (expected %u)\n", result2.ub[0], 56U);
         printf("  result3.ub[0] = %u (expected %u)\n", result3.ub[0], 34U);
      }
   }
   else
   {
      printf("cmpxchgb_4 ... failed\n");
   }

   return;
}

static void cmpxchgw_1(void)
{
   reg16_t preset0 = { .uw = { 123 } };
   reg16_t arg0 = { .uw = { 567 } };
   reg16_t arg1 = { .uw = { 123 } };
   reg32_t result0;
   reg16_t result1;
   reg16_t result2;
   reg16_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "movw %3, %%cx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgw %%bx, %%cx\n"
         "pushfl\n"
         "popl %0\n"
         "movw %%ax, %4\n"
         "movw %%bx, %5\n"
         "movw %%cx, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "ax", "bx", "cx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.uw[0] == 123 &&
          result2.uw[0] == 567 &&
          result3.uw[0] == 567 )
      {
         printf("cmpxchgw_1 ... ok\n");
      }
      else
      {
         printf("cmpxchgw_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 123);
         printf("  result2.uw[0] = %u (expected %u)\n", result2.uw[0], 567);
         printf("  result3.uw[0] = %u (expected %u)\n", result3.uw[0], 567);
      }
   }
   else
   {
      printf("cmpxchgw_1 ... failed\n");
   }

   return;
}

static void cmpxchgw_2(void)
{
   reg16_t preset0 = { .uw = { 123 } };
   reg16_t arg0 = { .uw = { 567 } };
   reg16_t arg1 = { .uw = { 345 } };
   reg32_t result0;
   reg16_t result1;
   reg16_t result2;
   reg16_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "movw %3, %%cx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgw %%bx, %%cx\n"
         "pushfl\n"
         "popl %0\n"
         "movw %%ax, %4\n"
         "movw %%bx, %5\n"
         "movw %%cx, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "ax", "bx", "cx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.uw[0] == 345 &&
          result2.uw[0] == 567 &&
          result3.uw[0] == 345 )
      {
         printf("cmpxchgw_2 ... ok\n");
      }
      else
      {
         printf("cmpxchgw_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 345);
         printf("  result2.uw[0] = %u (expected %u)\n", result2.uw[0], 567);
         printf("  result3.uw[0] = %u (expected %u)\n", result3.uw[0], 345);
      }
   }
   else
   {
      printf("cmpxchgw_2 ... failed\n");
   }

   return;
}

static void cmpxchgw_3(void)
{
   reg16_t preset0 = { .uw = { 123 } };
   reg16_t arg0 = { .uw = { 567 } };
   reg16_t arg1 = { .uw = { 123 } };
   reg32_t result0;
   reg16_t result1;
   reg16_t result2;
   reg16_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movw %2, %%ax\n"
         "movw %3, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgw %%bx, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movw %%ax, %5\n"
         "movw %%bx, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.uw[0] == 123 &&
          result2.uw[0] == 567 &&
          result3.uw[0] == 567 )
      {
         printf("cmpxchgw_3 ... ok\n");
      }
      else
      {
         printf("cmpxchgw_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 123);
         printf("  result2.uw[0] = %u (expected %u)\n", result2.uw[0], 567);
         printf("  result3.uw[0] = %u (expected %u)\n", result3.uw[0], 567);
      }
   }
   else
   {
      printf("cmpxchgw_3 ... failed\n");
   }

   return;
}

static void cmpxchgw_4(void)
{
   reg16_t preset0 = { .uw = { 123 } };
   reg16_t arg0 = { .uw = { 567 } };
   reg16_t arg1 = { .uw = { 345 } };
   reg32_t result0;
   reg16_t result1;
   reg16_t result2;
   reg16_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movw %2, %%ax\n"
         "movw %3, %%bx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgw %%bx, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movw %%ax, %5\n"
         "movw %%bx, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.uw[0] == 345 &&
          result2.uw[0] == 567 &&
          result3.uw[0] == 345 )
      {
         printf("cmpxchgw_4 ... ok\n");
      }
      else
      {
         printf("cmpxchgw_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 345);
         printf("  result2.uw[0] = %u (expected %u)\n", result2.uw[0], 567);
         printf("  result3.uw[0] = %u (expected %u)\n", result3.uw[0], 345);
      }
   }
   else
   {
      printf("cmpxchgw_4 ... failed\n");
   }

   return;
}

static void cmpxchgl_1(void)
{
   reg32_t preset0 = { .ud = { 1234UL } };
   reg32_t arg0 = { .ud = { 5678UL } };
   reg32_t arg1 = { .ud = { 1234UL } };
   reg32_t result0;
   reg32_t result1;
   reg32_t result2;
   reg32_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "movl %3, %%ecx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgl %%ebx, %%ecx\n"
         "pushfl\n"
         "popl %0\n"
         "movl %%eax, %4\n"
         "movl %%ebx, %5\n"
         "movl %%ecx, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "eax", "ebx", "ecx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.ud[0] == 1234UL &&
          result2.ud[0] == 5678UL &&
          result3.ud[0] == 5678UL )
      {
         printf("cmpxchgl_1 ... ok\n");
      }
      else
      {
         printf("cmpxchgl_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 1234UL);
         printf("  result2.ud[0] = %lu (expected %lu)\n", result2.ud[0], 5678UL);
         printf("  result3.ud[0] = %lu (expected %lu)\n", result3.ud[0], 5678UL);
      }
   }
   else
   {
      printf("cmpxchgl_1 ... failed\n");
   }

   return;
}

static void cmpxchgl_2(void)
{
   reg32_t preset0 = { .ud = { 1234UL } };
   reg32_t arg0 = { .ud = { 5678UL } };
   reg32_t arg1 = { .ud = { 3456UL } };
   reg32_t result0;
   reg32_t result1;
   reg32_t result2;
   reg32_t result3;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "movl %3, %%ecx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgl %%ebx, %%ecx\n"
         "pushfl\n"
         "popl %0\n"
         "movl %%eax, %4\n"
         "movl %%ebx, %5\n"
         "movl %%ecx, %6\n"
         "frstor %7\n"
         : "=m" (result0)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (result3), "m" (state[0])
         : "eax", "ebx", "ecx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.ud[0] == 3456UL &&
          result2.ud[0] == 5678UL &&
          result3.ud[0] == 3456UL )
      {
         printf("cmpxchgl_2 ... ok\n");
      }
      else
      {
         printf("cmpxchgl_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 3456UL);
         printf("  result2.ud[0] = %lu (expected %lu)\n", result2.ud[0], 5678UL);
         printf("  result3.ud[0] = %lu (expected %lu)\n", result3.ud[0], 3456UL);
      }
   }
   else
   {
      printf("cmpxchgl_2 ... failed\n");
   }

   return;
}

static void cmpxchgl_3(void)
{
   reg32_t preset0 = { .ud = { 1234UL } };
   reg32_t arg0 = { .ud = { 5678UL } };
   reg32_t arg1 = { .ud = { 1234UL } };
   reg32_t result0;
   reg32_t result1;
   reg32_t result2;
   reg32_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movl %2, %%eax\n"
         "movl %3, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "cmpxchgl %%ebx, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movl %%eax, %5\n"
         "movl %%ebx, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000040UL &&
          result1.ud[0] == 1234UL &&
          result2.ud[0] == 5678UL &&
          result3.ud[0] == 5678UL )
      {
         printf("cmpxchgl_3 ... ok\n");
      }
      else
      {
         printf("cmpxchgl_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000040UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 1234UL);
         printf("  result2.ud[0] = %lu (expected %lu)\n", result2.ud[0], 5678UL);
         printf("  result3.ud[0] = %lu (expected %lu)\n", result3.ud[0], 5678UL);
      }
   }
   else
   {
      printf("cmpxchgl_3 ... failed\n");
   }

   return;
}

static void cmpxchgl_4(void)
{
   reg32_t preset0 = { .ud = { 1234UL } };
   reg32_t arg0 = { .ud = { 5678UL } };
   reg32_t arg1 = { .ud = { 3456UL } };
   reg32_t result0;
   reg32_t result1;
   reg32_t result2;
   reg32_t result3 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %7\n"
         "movl %2, %%eax\n"
         "movl %3, %%ebx\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "cmpxchgl %%ebx, %1\n"
         "pushfl\n"
         "popl %0\n"
         "movl %%eax, %5\n"
         "movl %%ebx, %6\n"
         "frstor %7\n"
         : "=m" (result0), "=m" (result3)
         : "m" (preset0), "m" (arg0), "m" (arg1), "m" (result1), "m" (result2), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x00000040UL) == 0x00000000UL &&
          result1.ud[0] == 3456UL &&
          result2.ud[0] == 5678UL &&
          result3.ud[0] == 3456UL )
      {
         printf("cmpxchgl_4 ... ok\n");
      }
      else
      {
         printf("cmpxchgl_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000040UL, result0.ud[0] & 0x00000040UL, 0x00000000UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 3456UL);
         printf("  result2.ud[0] = %lu (expected %lu)\n", result2.ud[0], 5678UL);
         printf("  result3.ud[0] = %lu (expected %lu)\n", result3.ud[0], 3456UL);
      }
   }
   else
   {
      printf("cmpxchgl_4 ... failed\n");
   }

   return;
}

static void cwd_1(void)
{
   reg16_t preset0 = { .uw = { 0x1234 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "cwd\n"
         "movw %%dx, %1\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void cwd_2(void)
{
   reg16_t preset0 = { .uw = { 0xfedc } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "cwd\n"
         "movw %%dx, %1\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void cwde_1(void)
{
   reg16_t preset0 = { .sw = { 12345 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "cwde\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.sd[0] == 12345L )
      {
         printf("cwde_1 ... ok\n");
      }
      else
      {
         printf("cwde_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], 12345L);
      }
   }
   else
   {
      printf("cwde_1 ... failed\n");
   }

   return;
}

static void cwde_2(void)
{
   reg16_t preset0 = { .sw = { -12345 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "cwde\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.sd[0] == -12345L )
      {
         printf("cwde_2 ... ok\n");
      }
      else
      {
         printf("cwde_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -12345L);
      }
   }
   else
   {
      printf("cwde_2 ... failed\n");
   }

   return;
}

static void daa_1(void)
{
   reg8_t preset0 = { .ub = { 0xaeU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff72a, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "daa\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x14U &&
          (result1.ud[0] & 0x000000d5UL) == 0x00000015UL )
      {
         printf("daa_1 ... ok\n");
      }
      else
      {
         printf("daa_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x14U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000000d5UL, result1.ud[0] & 0x000000d5UL, 0x00000015UL);
      }
   }
   else
   {
      printf("daa_1 ... failed\n");
   }

   return;
}

static void daa_2(void)
{
   reg8_t preset0 = { .ub = { 0x2eU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff72a, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "daa\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x34U &&
          (result1.ud[0] & 0x000000d5UL) == 0x00000010UL )
      {
         printf("daa_2 ... ok\n");
      }
      else
      {
         printf("daa_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x34U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000000d5UL, result1.ud[0] & 0x000000d5UL, 0x00000010UL);
      }
   }
   else
   {
      printf("daa_2 ... failed\n");
   }

   return;
}

static void das_1(void)
{
   reg8_t preset0 = { .ub = { 0xeeU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff72a, (%%esp)\n"
         "orl $0x00000895, (%%esp)\n"
         "popfl\n"
         "das\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x88U &&
          (result1.ud[0] & 0x000000d5UL) == 0x00000095UL )
      {
         printf("das_1 ... ok\n");
      }
      else
      {
         printf("das_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x88U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000000d5UL, result1.ud[0] & 0x000000d5UL, 0x00000095UL);
      }
   }
   else
   {
      printf("das_1 ... failed\n");
   }

   return;
}

static void decb_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "decb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void decb_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "decb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "decw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "decw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "decl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "decl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void divb_1(void)
{
   reg16_t preset0 = { .uw = { 30276 } };
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movb %1, %%bl\n"
         "divb %%bl\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bl"
      );

      if (result0.ub[0] == 246U &&
          result1.ub[0] == 18U )
      {
         printf("divb_1 ... ok\n");
      }
      else
      {
         printf("divb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 246U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 18U);
      }
   }
   else
   {
      printf("divb_1 ... failed\n");
   }

   return;
}

static void divb_2(void)
{
   reg16_t preset0 = { .uw = { 30276 } };
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "divb %1\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

      if (result0.ub[0] == 246U &&
          result1.ub[0] == 18U )
      {
         printf("divb_2 ... ok\n");
      }
      else
      {
         printf("divb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 246U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 18U);
      }
   }
   else
   {
      printf("divb_2 ... failed\n");
   }

   return;
}

static void divw_1(void)
{
   reg16_t preset0 = { .uw = { 464 } };
   reg16_t preset1 = { .uw = { 58794 } };
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movw %0, %%dx\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "divw %%bx\n"
         "movw %%ax, %3\n"
         "movw %%dx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "dx", "ax", "bx"
      );

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

   return;
}

static void divw_2(void)
{
   reg16_t preset0 = { .uw = { 464 } };
   reg16_t preset1 = { .uw = { 58794 } };
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movw %0, %%dx\n"
         "movw %1, %%ax\n"
         "divw %2\n"
         "movw %%ax, %3\n"
         "movw %%dx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "dx", "ax"
      );

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

   return;
}

static void divl_1(void)
{
   reg32_t preset0 = { .ud = { 251958UL } };
   reg32_t preset1 = { .ud = { 673192206UL } };
   reg32_t arg0 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movl %0, %%edx\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "divl %%ebx\n"
         "movl %%eax, %3\n"
         "movl %%edx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "edx", "eax", "ebx"
      );

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

   return;
}

static void divl_2(void)
{
   reg32_t preset0 = { .ud = { 251958UL } };
   reg32_t preset1 = { .ud = { 673192206UL } };
   reg32_t arg0 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movl %0, %%edx\n"
         "movl %1, %%eax\n"
         "divl %2\n"
         "movl %%eax, %3\n"
         "movl %%edx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "edx", "eax"
      );

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

   return;
}

static void idivb_1(void)
{
   reg16_t preset0 = { .sw = { -15157 } };
   reg8_t arg0 = { .sb = { 123 } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movb %1, %%bl\n"
         "idivb %%bl\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bl"
      );

      if (result0.sb[0] == -123 &&
          result1.sb[0] == -28 )
      {
         printf("idivb_1 ... ok\n");
      }
      else
      {
         printf("idivb_1 ... not ok\n");
         printf("  result0.sb[0] = %d (expected %d)\n", result0.sb[0], -123);
         printf("  result1.sb[0] = %d (expected %d)\n", result1.sb[0], -28);
      }
   }
   else
   {
      printf("idivb_1 ... failed\n");
   }

   return;
}

static void idivb_2(void)
{
   reg16_t preset0 = { .sw = { 15157 } };
   reg8_t arg0 = { .sb = { -123 } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "idivb %1\n"
         "movb %%al, %2\n"
         "movb %%ah, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

      if (result0.sb[0] == -123 &&
          result1.sb[0] == 28 )
      {
         printf("idivb_2 ... ok\n");
      }
      else
      {
         printf("idivb_2 ... not ok\n");
         printf("  result0.sb[0] = %d (expected %d)\n", result0.sb[0], -123);
         printf("  result1.sb[0] = %d (expected %d)\n", result1.sb[0], 28);
      }
   }
   else
   {
      printf("idivb_2 ... failed\n");
   }

   return;
}

static void idivw_1(void)
{
   reg16_t preset0 = { .sw = { -464 } };
   reg16_t preset1 = { .sw = { -23456 } };
   reg16_t arg0 = { .sw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movw %0, %%dx\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "idivw %%bx\n"
         "movw %%ax, %3\n"
         "movw %%dx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "dx", "ax", "bx"
      );

      if (result0.sw[0] == -2459 &&
          result1.sw[0] == -10269 )
      {
         printf("idivw_1 ... ok\n");
      }
      else
      {
         printf("idivw_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -2459);
         printf("  result1.sw[0] = %d (expected %d)\n", result1.sw[0], -10269);
      }
   }
   else
   {
      printf("idivw_1 ... failed\n");
   }

   return;
}

static void idivw_2(void)
{
   reg16_t preset0 = { .sw = { 464 } };
   reg16_t preset1 = { .sw = { 23456 } };
   reg16_t arg0 = { .sw = { -12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movw %0, %%dx\n"
         "movw %1, %%ax\n"
         "idivw %2\n"
         "movw %%ax, %3\n"
         "movw %%dx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "dx", "ax"
      );

      if (result0.sw[0] == -2465 &&
          result1.sw[0] == 1735 )
      {
         printf("idivw_2 ... ok\n");
      }
      else
      {
         printf("idivw_2 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -2465);
         printf("  result1.sw[0] = %d (expected %d)\n", result1.sw[0], 1735);
      }
   }
   else
   {
      printf("idivw_2 ... failed\n");
   }

   return;
}

static void idivl_1(void)
{
   reg32_t preset0 = { .sd = { -251959L } };
   reg32_t preset1 = { .sd = { -673192206L } };
   reg32_t arg0 = { .sd = { 87654321L } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movl %0, %%edx\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "idivl %%ebx\n"
         "movl %%eax, %3\n"
         "movl %%edx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "edx", "eax", "ebx"
      );

      if (result0.sd[0] == -12345678L &&
          result1.sd[0] == -20783136L )
      {
         printf("idivl_1 ... ok\n");
      }
      else
      {
         printf("idivl_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -12345678L);
         printf("  result1.sd[0] = %ld (expected %ld)\n", result1.sd[0], -20783136L);
      }
   }
   else
   {
      printf("idivl_1 ... failed\n");
   }

   return;
}

static void idivl_2(void)
{
   reg32_t preset0 = { .sd = { 251958L } };
   reg32_t preset1 = { .sd = { 673192206L } };
   reg32_t arg0 = { .sd = { -87654321L } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %5\n"
         "movl %0, %%edx\n"
         "movl %1, %%eax\n"
         "idivl %2\n"
         "movl %%eax, %3\n"
         "movl %%edx, %4\n"
         "frstor %5\n"
         :
         : "m" (preset0), "m" (preset1), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "edx", "eax"
      );

      if (result0.sd[0] == -12345678L &&
          result1.sd[0] == 20783136L )
      {
         printf("idivl_2 ... ok\n");
      }
      else
      {
         printf("idivl_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -12345678L);
         printf("  result1.sd[0] = %ld (expected %ld)\n", result1.sd[0], 20783136L);
      }
   }
   else
   {
      printf("idivl_2 ... failed\n");
   }

   return;
}

static void imulb_1(void)
{
   reg8_t preset0 = { .sb = { 123 } };
   reg8_t arg0 = { .sb = { -123 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "imulb %%bl\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

      if (result0.sw[0] == -15129 )
      {
         printf("imulb_1 ... ok\n");
      }
      else
      {
         printf("imulb_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -15129);
      }
   }
   else
   {
      printf("imulb_1 ... failed\n");
   }

   return;
}

static void imulb_2(void)
{
   reg8_t preset0 = { .sb = { -123 } };
   reg8_t arg0 = { .sb = { 123 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "imulb %1\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.sw[0] == -15129 )
      {
         printf("imulb_2 ... ok\n");
      }
      else
      {
         printf("imulb_2 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -15129);
      }
   }
   else
   {
      printf("imulb_2 ... failed\n");
   }

   return;
}

static void imulw_1(void)
{
   reg16_t preset0 = { .sw = { -12345 } };
   reg16_t arg0 = { .sw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "imulw %%bx\n"
         "movw %%dx, %2\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.sw[0] == -2326 &&
          result1.sw[0] == -27825 )
      {
         printf("imulw_1 ... ok\n");
      }
      else
      {
         printf("imulw_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -2326);
         printf("  result1.sw[0] = %d (expected %d)\n", result1.sw[0], -27825);
      }
   }
   else
   {
      printf("imulw_1 ... failed\n");
   }

   return;
}

static void imulw_2(void)
{
   reg16_t preset0 = { .sw = { 12345 } };
   reg16_t arg0 = { .sw = { -12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "imulw %1\n"
         "movw %%dx, %2\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

      if (result0.sw[0] == -2326 &&
          result1.sw[0] == -27825 )
      {
         printf("imulw_2 ... ok\n");
      }
      else
      {
         printf("imulw_2 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -2326);
         printf("  result1.sw[0] = %d (expected %d)\n", result1.sw[0], -27825);
      }
   }
   else
   {
      printf("imulw_2 ... failed\n");
   }

   return;
}

static void imull_1(void)
{
   reg32_t preset0 = { .sd = { -12345678L } };
   reg32_t arg0 = { .sd = { 12345678L } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "imull %%ebx\n"
         "movl %%edx, %2\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.sd[0] == -35488L &&
          result1.sd[0] == -260846532L )
      {
         printf("imull_1 ... ok\n");
      }
      else
      {
         printf("imull_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -35488L);
         printf("  result1.sd[0] = %ld (expected %ld)\n", result1.sd[0], -260846532L);
      }
   }
   else
   {
      printf("imull_1 ... failed\n");
   }

   return;
}

static void imull_2(void)
{
   reg32_t preset0 = { .sd = { 12345678L } };
   reg32_t arg0 = { .sd = { -12345678L } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "imull %1\n"
         "movl %%edx, %2\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax"
      );

      if (result0.sd[0] == -35488L &&
          result1.sd[0] == -260846532L )
      {
         printf("imull_2 ... ok\n");
      }
      else
      {
         printf("imull_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -35488L);
         printf("  result1.sd[0] = %ld (expected %ld)\n", result1.sd[0], -260846532L);
      }
   }
   else
   {
      printf("imull_2 ... failed\n");
   }

   return;
}

static void imulw_3(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "imulw $123, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void imulw_4(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t arg2 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "imulw $123, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

static void imulw_5(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t arg2 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "imulw $123, %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void imulw_6(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "imulw $123, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void imulw_7(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t arg2 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "imulw $123, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

static void imulw_8(void)
{
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t arg2 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "imulw $123, %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void imulw_9(void)
{
   reg16_t arg0 = { .uw = { 123 } };
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "imulw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

static void imulw_10(void)
{
   reg16_t arg0 = { .uw = { 123 } };
   reg16_t arg1 = { .uw = { 456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "imulw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void imull_3(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "imull $123, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void imull_4(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t arg2 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "imull $123, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void imull_5(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t arg2 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "imull $123, %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void imull_6(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "imull $12345, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void imull_7(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t arg2 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "imull $12345, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void imull_8(void)
{
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t arg2 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "imull $12345, %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void imull_9(void)
{
   reg32_t arg0 = { .ud = { 12345UL } };
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "imull %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void imull_10(void)
{
   reg32_t arg0 = { .ud = { 12345UL } };
   reg32_t arg1 = { .ud = { 67890UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "imull %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void incb_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "incb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void incb_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "incb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "incw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "incw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "incl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "incl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void lahf_1(void)
{
   reg8_t preset0 = { .ub = { 0x28U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%ah\n"
         "pushfl\n"
         "andl $0xffffff00, (%%esp)\n"
         "orl $0x000000fd, (%%esp)\n"
         "popfl\n"
         "lahf\n"
         "movb %%ah, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "ah"
      );

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

   return;
}

static void lahf_2(void)
{
   reg8_t preset0 = { .ub = { 0xfdU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%ah\n"
         "pushfl\n"
         "andl $0xffffff00, (%%esp)\n"
         "orl $0x00000028, (%%esp)\n"
         "popfl\n"
         "lahf\n"
         "movb %%ah, %1\n"
         "frstor %2\n"
         :
         : "m" (preset0), "m" (result0), "m" (state[0])
         : "ah"
      );

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

   return;
}

static void movb_1(void)
{
   reg8_t arg1 = { .ub = { 0U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "movb $123, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void movb_2(void)
{
   reg8_t arg1 = { .ub = { 0U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb $123, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void movb_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t arg1 = { .ub = { 0U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "movb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

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

   return;
}

static void movb_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t arg1 = { .ub = { 0U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

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

   return;
}

static void movb_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t arg1 = { .ub = { 0U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "movb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "movw $12345, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw $12345, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void movw_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 %0, %%ax\n"
         "movw %1, %%bx\n"
         "movw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "movw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void movw_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, %%bx\n"
         "movw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "movl $12345678, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void movl_3(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 %0, %%eax\n"
         "movl %1, %%ebx\n"
         "movl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "movl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void movl_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, %%ebx\n"
         "movl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void movsbw_1(void)
{
   reg8_t arg0 = { .sb = { 123 } };
   reg16_t arg1 = { .sw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movw %1, %%bx\n"
         "movsbw %%al, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bx"
      );

      if (result0.sw[0] == 123 )
      {
         printf("movsbw_1 ... ok\n");
      }
      else
      {
         printf("movsbw_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], 123);
      }
   }
   else
   {
      printf("movsbw_1 ... failed\n");
   }

   return;
}

static void movsbw_2(void)
{
   reg8_t arg0 = { .sb = { -123 } };
   reg16_t arg1 = { .sw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "movsbw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

      if (result0.sw[0] == -123 )
      {
         printf("movsbw_2 ... ok\n");
      }
      else
      {
         printf("movsbw_2 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -123);
      }
   }
   else
   {
      printf("movsbw_2 ... failed\n");
   }

   return;
}

static void movsbl_1(void)
{
   reg8_t arg0 = { .sb = { 123 } };
   reg32_t arg1 = { .sd = { 0L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movl %1, %%ebx\n"
         "movsbl %%al, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "ebx"
      );

      if (result0.sd[0] == 123L )
      {
         printf("movsbl_1 ... ok\n");
      }
      else
      {
         printf("movsbl_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], 123L);
      }
   }
   else
   {
      printf("movsbl_1 ... failed\n");
   }

   return;
}

static void movsbl_2(void)
{
   reg8_t arg0 = { .sb = { -123 } };
   reg32_t arg1 = { .sd = { 0L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "movsbl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.sd[0] == -123L )
      {
         printf("movsbl_2 ... ok\n");
      }
      else
      {
         printf("movsbl_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -123L);
      }
   }
   else
   {
      printf("movsbl_2 ... failed\n");
   }

   return;
}

static void movswl_1(void)
{
   reg16_t arg0 = { .sw = { 12345 } };
   reg32_t arg1 = { .sd = { 0L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movl %1, %%ebx\n"
         "movswl %%ax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "ebx"
      );

      if (result0.sd[0] == 12345L )
      {
         printf("movswl_1 ... ok\n");
      }
      else
      {
         printf("movswl_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], 12345L);
      }
   }
   else
   {
      printf("movswl_1 ... failed\n");
   }

   return;
}

static void movswl_2(void)
{
   reg16_t arg0 = { .sw = { -12345 } };
   reg32_t arg1 = { .sd = { 0L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "movswl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.sd[0] == -12345L )
      {
         printf("movswl_2 ... ok\n");
      }
      else
      {
         printf("movswl_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -12345L);
      }
   }
   else
   {
      printf("movswl_2 ... failed\n");
   }

   return;
}

static void movzbw_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movw %1, %%bx\n"
         "movzbw %%al, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bx"
      );

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

   return;
}

static void movzbw_2(void)
{
   reg8_t arg0 = { .ub = { 246U } };
   reg16_t arg1 = { .uw = { 0 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "movzbw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void movzbl_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movl %1, %%ebx\n"
         "movzbl %%al, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "ebx"
      );

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

   return;
}

static void movzbl_2(void)
{
   reg8_t arg0 = { .ub = { 246U } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "movzbl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movl %1, %%ebx\n"
         "movzwl %%ax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "ebx"
      );

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

   return;
}

static void movzwl_2(void)
{
   reg16_t arg0 = { .uw = { 49380 } };
   reg32_t arg1 = { .ud = { 0UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "movzwl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void mulb_1(void)
{
   reg8_t preset0 = { .ub = { 123U } };
   reg8_t arg0 = { .ub = { 123U } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "mulb %%bl\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

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

   return;
}

static void mulb_2(void)
{
   reg8_t preset0 = { .ub = { 123U } };
   reg8_t arg0 = { .ub = { 123U } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "mulb %1\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void mulw_1(void)
{
   reg16_t preset0 = { .uw = { 12345 } };
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "mulw %%bx\n"
         "movw %%dx, %2\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

static void mulw_2(void)
{
   reg16_t preset0 = { .uw = { 12345 } };
   reg16_t arg0 = { .uw = { 12345 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "mulw %1\n"
         "movw %%dx, %2\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void mull_1(void)
{
   reg32_t preset0 = { .ud = { 12345678UL } };
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "mull %%ebx\n"
         "movl %%edx, %2\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void mull_2(void)
{
   reg32_t preset0 = { .ud = { 12345678UL } };
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "mull %1\n"
         "movl %%edx, %2\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         :
         : "m" (preset0), "m" (arg0), "m" (result0), "m" (result1), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void negb_1(void)
{
   reg8_t arg0 = { .sb = { 123 } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "negb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.sb[0] == -123 )
      {
         printf("negb_1 ... ok\n");
      }
      else
      {
         printf("negb_1 ... not ok\n");
         printf("  result0.sb[0] = %d (expected %d)\n", result0.sb[0], -123);
      }
   }
   else
   {
      printf("negb_1 ... failed\n");
   }

   return;
}

static void negb_2(void)
{
   reg8_t arg0 = { .sb = { -123 } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "negb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.sb[0] == 123 )
      {
         printf("negb_2 ... ok\n");
      }
      else
      {
         printf("negb_2 ... not ok\n");
         printf("  result0.sb[0] = %d (expected %d)\n", result0.sb[0], 123);
      }
   }
   else
   {
      printf("negb_2 ... failed\n");
   }

   return;
}

static void negw_1(void)
{
   reg16_t arg0 = { .sw = { 12345 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "negw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.sw[0] == -12345 )
      {
         printf("negw_1 ... ok\n");
      }
      else
      {
         printf("negw_1 ... not ok\n");
         printf("  result0.sw[0] = %d (expected %d)\n", result0.sw[0], -12345);
      }
   }
   else
   {
      printf("negw_1 ... failed\n");
   }

   return;
}

static void negw_2(void)
{
   reg16_t arg0 = { .sw = { -12345 } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "negw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void negl_1(void)
{
   reg32_t arg0 = { .sd = { 12345678L } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "negl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.sd[0] == -12345678L )
      {
         printf("negl_1 ... ok\n");
      }
      else
      {
         printf("negl_1 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], -12345678L);
      }
   }
   else
   {
      printf("negl_1 ... failed\n");
   }

   return;
}

static void negl_2(void)
{
   reg32_t arg0 = { .sd = { -12345678L } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "negl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.sd[0] == 12345678L )
      {
         printf("negl_2 ... ok\n");
      }
      else
      {
         printf("negl_2 ... not ok\n");
         printf("  result0.sd[0] = %ld (expected %ld)\n", result0.sd[0], 12345678L);
      }
   }
   else
   {
      printf("negl_2 ... failed\n");
   }

   return;
}

static void notb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "notb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void notb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "notb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void notw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "notw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void notw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "notw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void notl_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "notl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void notl_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "notl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void orb_1(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "orb $0x34, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void orb_2(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "orb $0x34, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void orb_3(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "orb $0x34, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void orb_4(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "orb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

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

   return;
}

static void orb_5(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "orb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

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

   return;
}

static void orb_6(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "orb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void orw_1(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "orw $0x31, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void orw_2(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "orw $0x4231, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void orw_3(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%bx\n"
         "orw $0x4231, %%bx\n"
         "movw %%bx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void orw_4(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "orw $0x4231, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "orw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "orw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

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

   return;
}

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

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "orw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

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

   return;
}

static void orl_1(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "orl $0x31, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void orl_2(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "orl $0x86427531, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void orl_3(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%ebx\n"
         "orl $0x86427531, %%ebx\n"
         "movl %%ebx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void orl_4(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "orl $0x86427531, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void orl_5(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "orl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

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

   return;
}

static void orl_6(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "orl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void orl_7(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "orl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

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

   return;
}

static void rclb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb %%al\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x94U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_1 ... ok\n");
      }
      else
      {
         printf("rclb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x94U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_1 ... failed\n");
   }

   return;
}

static void rclb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0x94U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_2 ... ok\n");
      }
      else
      {
         printf("rclb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x94U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_2 ... failed\n");
   }

   return;
}

static void rclb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb $2, %%al\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x29U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_3 ... ok\n");
      }
      else
      {
         printf("rclb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x29U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_3 ... failed\n");
   }

   return;
}

static void rclb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb $2, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 0x29U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_4 ... ok\n");
      }
      else
      {
         printf("rclb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x29U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_4 ... failed\n");
   }

   return;
}

static void rclb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movb %2, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb %%cl, %%al\n"
         "movb %%al, %3\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

      if (result0.ub[0] == 0x29U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_5 ... ok\n");
      }
      else
      {
         printf("rclb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x29U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_5 ... failed\n");
   }

   return;
}

static void rclb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclb %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ub[0] == 0x29U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclb_6 ... ok\n");
      }
      else
      {
         printf("rclb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x29U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclb_6 ... failed\n");
   }

   return;
}

static void rclw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0xe194 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_1 ... ok\n");
      }
      else
      {
         printf("rclw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe194);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_1 ... failed\n");
   }

   return;
}

static void rclw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclw %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.uw[0] == 0xe194 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_2 ... ok\n");
      }
      else
      {
         printf("rclw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe194);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_2 ... failed\n");
   }

   return;
}

static void rclw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x0ca7 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_3 ... ok\n");
      }
      else
      {
         printf("rclw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca7);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_3 ... failed\n");
   }

   return;
}

static void rclw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclw $4, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x0ca7 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_4 ... ok\n");
      }
      else
      {
         printf("rclw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca7);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_4 ... failed\n");
   }

   return;
}

static void rclw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x0ca7 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_5 ... ok\n");
      }
      else
      {
         printf("rclw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca7);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_5 ... failed\n");
   }

   return;
}

static void rclw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rclw %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.uw[0] == 0x0ca7 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rclw_6 ... ok\n");
      }
      else
      {
         printf("rclw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca7);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rclw_6 ... failed\n");
   }

   return;
}

static void rcll_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0xfe01e194UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_1 ... ok\n");
      }
      else
      {
         printf("rcll_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e194UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_1 ... failed\n");
   }

   return;
}

static void rcll_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcll %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ud[0] == 0xfe01e194UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_2 ... ok\n");
      }
      else
      {
         printf("rcll_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e194UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_2 ... failed\n");
   }

   return;
}

static void rcll_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x00f0ca7fUL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_3 ... ok\n");
      }
      else
      {
         printf("rcll_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca7fUL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_3 ... failed\n");
   }

   return;
}

static void rcll_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcll $8, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x00f0ca7fUL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_4 ... ok\n");
      }
      else
      {
         printf("rcll_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca7fUL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_4 ... failed\n");
   }

   return;
}

static void rcll_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x00f0ca7fUL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_5 ... ok\n");
      }
      else
      {
         printf("rcll_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca7fUL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_5 ... failed\n");
   }

   return;
}

static void rcll_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcll %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ud[0] == 0x00f0ca7fUL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcll_6 ... ok\n");
      }
      else
      {
         printf("rcll_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca7fUL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcll_6 ... failed\n");
   }

   return;
}

static void rcrb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "rcrb %%al\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0xe5U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrb_1 ... ok\n");
      }
      else
      {
         printf("rcrb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0xe5U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrb_1 ... failed\n");
   }

   return;
}

static void rcrb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "rcrb %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0xe5U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrb_2 ... ok\n");
      }
      else
      {
         printf("rcrb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0xe5U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrb_2 ... failed\n");
   }

   return;
}

static void rcrb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrb $2, %%al\n"
         "movb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result1)
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x32U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrb_3 ... ok\n");
      }
      else
      {
         printf("rcrb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrb_3 ... failed\n");
   }

   return;
}

static void rcrb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrb $2, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 0x32U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrb_4 ... ok\n");
      }
      else
      {
         printf("rcrb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrb_4 ... failed\n");
   }

   return;
}

static void rcrb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movb %2, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrb %%cl, %%al\n"
         "movb %%al, %3\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

      if (result0.ub[0] == 0x32U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrb_5 ... ok\n");
      }
      else
      {
         printf("rcrb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrb_5 ... failed\n");
   }

   return;
}

static void rcrb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrb %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ub[0] == 0x32U &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrb_6 ... ok\n");
      }
      else
      {
         printf("rcrb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrb_6 ... failed\n");
   }

   return;
}

static void rcrw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0xf865 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrw_1 ... ok\n");
      }
      else
      {
         printf("rcrw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xf865);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrw_1 ... failed\n");
   }

   return;
}

static void rcrw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "rcrw %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.uw[0] == 0xf865 &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrw_2 ... ok\n");
      }
      else
      {
         printf("rcrw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xf865);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrw_2 ... failed\n");
   }

   return;
}

static void rcrw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4f0c &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrw_3 ... ok\n");
      }
      else
      {
         printf("rcrw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4f0c);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrw_3 ... failed\n");
   }

   return;
}

static void rcrw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrw $4, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x4f0c &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrw_4 ... ok\n");
      }
      else
      {
         printf("rcrw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4f0c);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrw_4 ... failed\n");
   }

   return;
}

static void rcrw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.uw[0] == 0x4f0c &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrw_5 ... ok\n");
      }
      else
      {
         printf("rcrw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4f0c);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrw_5 ... failed\n");
   }

   return;
}

static void rcrw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrw %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.uw[0] == 0x4f0c &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrw_6 ... ok\n");
      }
      else
      {
         printf("rcrw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x4f0c);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrw_6 ... failed\n");
   }

   return;
}

static void rcrl_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0xff807865UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrl_1 ... ok\n");
      }
      else
      {
         printf("rcrl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xff807865UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrl_1 ... failed\n");
   }

   return;
}

static void rcrl_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "rcrl %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ud[0] == 0xff807865UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000000UL )
      {
         printf("rcrl_2 ... ok\n");
      }
      else
      {
         printf("rcrl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xff807865UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000000UL);
      }
   }
   else
   {
      printf("rcrl_2 ... failed\n");
   }

   return;
}

static void rcrl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x94ff00f0UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrl_3 ... ok\n");
      }
      else
      {
         printf("rcrl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94ff00f0UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrl_3 ... failed\n");
   }

   return;
}

static void rcrl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrl $8, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %3\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x94ff00f0UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrl_4 ... ok\n");
      }
      else
      {
         printf("rcrl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94ff00f0UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrl_4 ... failed\n");
   }

   return;
}

static void rcrl_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

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

      if (result0.ud[0] == 0x94ff00f0UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrl_5 ... ok\n");
      }
      else
      {
         printf("rcrl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94ff00f0UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrl_5 ... failed\n");
   }

   return;
}

static void rcrl_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%cl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "rcrl %%cl, %0\n"
         "pushfl\n"
         "popl %1\n"
         "frstor %4\n"
         : "=m" (result0), "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ud[0] == 0x94ff00f0UL &&
          (result1.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("rcrl_6 ... ok\n");
      }
      else
      {
         printf("rcrl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94ff00f0UL);
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result1.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("rcrl_6 ... failed\n");
   }

   return;
}

static void rolb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "rolb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void rolb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rolb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void rolb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "rolb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void rolb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rolb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void rolb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "rolb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

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

   return;
}

static void rolb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "rolb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void rolw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "rolw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void rolw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rolw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void rolw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "rolw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void rolw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rolw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void rolw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "rolw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

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

   return;
}

static void rolw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "rolw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void roll_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "roll %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void roll_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "roll %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void roll_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "roll $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void roll_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "roll $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void roll_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "roll %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

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

   return;
}

static void roll_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "roll %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void rorb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "rorb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void rorb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void rorb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "rorb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void rorb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void rorb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "rorb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

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

   return;
}

static void rorb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "rorb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void rorw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "rorw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void rorw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void rorw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "rorw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void rorw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void rorw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "rorw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

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

   return;
}

static void rorw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "rorw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void rorl_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "rorl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void rorl_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void rorl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "rorl $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void rorl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "rorl $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void rorl_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "rorl %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

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

   return;
}

static void rorl_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "rorl %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sahf_1(void)
{
   reg8_t preset0 = { .ub = { 0xfdU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%ah\n"
         "pushfl\n"
         "andl $0xffffff00, (%%esp)\n"
         "orl $0x00000028, (%%esp)\n"
         "popfl\n"
         "sahf\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (preset0), "m" (state[0])
         : "ah"
      );

      if ((result0.ud[0] & 0x000000ffUL) == 0x000000d7UL )
      {
         printf("sahf_1 ... ok\n");
      }
      else
      {
         printf("sahf_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000000ffUL, result0.ud[0] & 0x000000ffUL, 0x000000d7UL);
      }
   }
   else
   {
      printf("sahf_1 ... failed\n");
   }

   return;
}

static void sahf_2(void)
{
   reg8_t preset0 = { .ub = { 0x28U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%ah\n"
         "pushfl\n"
         "andl $0xffffff00, (%%esp)\n"
         "orl $0x000000fd, (%%esp)\n"
         "popfl\n"
         "sahf\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (preset0), "m" (state[0])
         : "ah"
      );

      if ((result0.ud[0] & 0x000000ffUL) == 0x00000002UL )
      {
         printf("sahf_2 ... ok\n");
      }
      else
      {
         printf("sahf_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000000ffUL, result0.ud[0] & 0x000000ffUL, 0x00000002UL);
      }
   }
   else
   {
      printf("sahf_2 ... failed\n");
   }

   return;
}

static void salb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "salb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void salb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "salb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void salb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "salb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void salb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "salb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void salb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "salb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

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

   return;
}

static void salb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "salb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void salw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "salw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void salw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "salw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void salw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "salw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void salw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "salw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void salw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "salw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

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

   return;
}

static void salw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "salw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sall_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "sall %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void sall_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sall %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void sall_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "sall $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void sall_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sall $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sall_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "sall %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

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

   return;
}

static void sall_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "sall %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sarb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "sarb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sarb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void sarb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "sarb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sarb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sarb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "sarb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

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

   return;
}

static void sarb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "sarb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sarw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "sarw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void sarw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void sarw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "sarw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

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

   return;
}

static void sarw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sarw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "sarw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

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

   return;
}

static void sarw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "sarw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sarl_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "sarl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void sarl_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

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

   return;
}

static void sarl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "sarl $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

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

   return;
}

static void sarl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "sarl $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sarl_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "sarl %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

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

   return;
}

static void sarl_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "sarl %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

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

   return;
}

static void sbbb_1(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sbbb_2(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sbbb_3(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void sbbb_4(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

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

   return;
}

static void sbbb_5(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sbbb_6(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "sbbb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sbbb_7(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void sbbb_8(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void sbbb_9(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void sbbb_10(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void sbbb_11(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void sbbb_12(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_1(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_2(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_3(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_4(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_5(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_6(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_7(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sbbw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sbbw_8(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "sbbw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sbbw_9(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_10(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_11(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void sbbw_12(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

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

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

   return;
}

static void sbbw_13(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbw_14(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_1(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_2(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_3(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_4(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_5(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_6(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

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

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

   return;
}

static void sbbl_7(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sbbl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

static void sbbl_8(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "sbbl $12345678, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

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

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

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

   return;
}

static void seta_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "seta %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seta_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "seta %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seta_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "seta %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seta_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "seta %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seta_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void seta_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void seta_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void seta_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setae_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setae %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setae_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setae %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setae_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setae_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setb_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setb_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setb_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setb_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setbe_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setbe_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setbe_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setbe_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "setbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setbe_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setbe_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setbe_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setbe_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setc_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setc %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setc_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setc %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setc_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setc_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void sete_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sete %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sete_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "sete %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void sete_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void sete_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "setg %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setg_9(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_10(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_11(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_12(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_13(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_14(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_15(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setg_16(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setge_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setge_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setge_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setge_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setge_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setge_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setge_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setge_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setl_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setl_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setl_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setl_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setl_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setl_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setl_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setl_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "setle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setle_9(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_10(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_11(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_12(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_13(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_14(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_15(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setle_16(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setna_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setna %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setna_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setna %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setna_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setna %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setna_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "setna %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setna_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setna_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setna_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setna_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnae_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnae %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnae_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setnae %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnae_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnae_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnb_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnb_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setnb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnb_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnb_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnbe_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnbe_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setnbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnbe_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setnbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnbe_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbe, (%%esp)\n"
         "orl $0x00000041, (%%esp)\n"
         "popfl\n"
         "setnbe %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnbe_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnbe_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnbe_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnbe_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnc_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnc %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnc_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "setnc %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnc_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnc_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setne_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setne %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setne_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setne %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setne_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setne_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "setng %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setng_9(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_10(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_11(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_12(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_13(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_14(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_15(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setng_16(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnge_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnge_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setnge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnge_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setnge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnge_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setnge %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnge_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnge_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnge_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnge_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnl_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnl_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setnl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnl_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setnl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnl_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setnl %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnl_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnl_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnl_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnl_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000000c0, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_5(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_6(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000840, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_7(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x00000880, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_8(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff73f, (%%esp)\n"
         "orl $0x000008c0, (%%esp)\n"
         "popfl\n"
         "setnle %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnle_9(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_10(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_11(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_12(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_13(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_14(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_15(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnle_16(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setno_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setno %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setno_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "setno %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setno_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setno_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnp_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnp %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnp_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "setnp %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnp_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnp_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setns_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setns %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setns_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "setns %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setns_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setns_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnz_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setnz %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnz_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setnz %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setnz_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setnz_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void seto_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "seto %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seto_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffff7ff, (%%esp)\n"
         "orl $0x00000800, (%%esp)\n"
         "popfl\n"
         "seto %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void seto_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void seto_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

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

   return;
}

static void setp_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setp %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setp_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "setp %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

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

   return;
}

static void setp_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

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

      );

      if (result0.ub[0] == 0U )
      {
         printf("setp_3 ... ok\n");
      }
      else
      {
         printf("setp_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0U);
      }
   }
   else
   {
      printf("setp_3 ... failed\n");
   }

   return;
}

static void setp_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffffffb, (%%esp)\n"
         "orl $0x00000004, (%%esp)\n"
         "popfl\n"
         "setp %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 1U )
      {
         printf("setp_4 ... ok\n");
      }
      else
      {
         printf("setp_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 1U);
      }
   }
   else
   {
      printf("setp_4 ... failed\n");
   }

   return;
}

static void sets_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sets %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0U )
      {
         printf("sets_1 ... ok\n");
      }
      else
      {
         printf("sets_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0U);
      }
   }
   else
   {
      printf("sets_1 ... failed\n");
   }

   return;
}

static void sets_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "sets %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 1U )
      {
         printf("sets_2 ... ok\n");
      }
      else
      {
         printf("sets_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 1U);
      }
   }
   else
   {
      printf("sets_2 ... failed\n");
   }

   return;
}

static void sets_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "sets %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0U )
      {
         printf("sets_3 ... ok\n");
      }
      else
      {
         printf("sets_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0U);
      }
   }
   else
   {
      printf("sets_3 ... failed\n");
   }

   return;
}

static void sets_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffff7f, (%%esp)\n"
         "orl $0x00000080, (%%esp)\n"
         "popfl\n"
         "sets %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 1U )
      {
         printf("sets_4 ... ok\n");
      }
      else
      {
         printf("sets_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 1U);
      }
   }
   else
   {
      printf("sets_4 ... failed\n");
   }

   return;
}

static void setz_1(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setz %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0U )
      {
         printf("setz_1 ... ok\n");
      }
      else
      {
         printf("setz_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0U);
      }
   }
   else
   {
      printf("setz_1 ... failed\n");
   }

   return;
}

static void setz_2(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setz %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 1U )
      {
         printf("setz_2 ... ok\n");
      }
      else
      {
         printf("setz_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 1U);
      }
   }
   else
   {
      printf("setz_2 ... failed\n");
   }

   return;
}

static void setz_3(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "setz %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0U )
      {
         printf("setz_3 ... ok\n");
      }
      else
      {
         printf("setz_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0U);
      }
   }
   else
   {
      printf("setz_3 ... failed\n");
   }

   return;
}

static void setz_4(void)
{
   reg8_t arg0 = { .ub = { 123U } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xffffffbf, (%%esp)\n"
         "orl $0x00000040, (%%esp)\n"
         "popfl\n"
         "setz %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 1U )
      {
         printf("setz_4 ... ok\n");
      }
      else
      {
         printf("setz_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 1U);
      }
   }
   else
   {
      printf("setz_4 ... failed\n");
   }

   return;
}

static void shlb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "shlb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x94U )
      {
         printf("shlb_1 ... ok\n");
      }
      else
      {
         printf("shlb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x94U);
      }
   }
   else
   {
      printf("shlb_1 ... failed\n");
   }

   return;
}

static void shlb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shlb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0x94U )
      {
         printf("shlb_2 ... ok\n");
      }
      else
      {
         printf("shlb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x94U);
      }
   }
   else
   {
      printf("shlb_2 ... failed\n");
   }

   return;
}

static void shlb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "shlb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x28U )
      {
         printf("shlb_3 ... ok\n");
      }
      else
      {
         printf("shlb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x28U);
      }
   }
   else
   {
      printf("shlb_3 ... failed\n");
   }

   return;
}

static void shlb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shlb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 0x28U )
      {
         printf("shlb_4 ... ok\n");
      }
      else
      {
         printf("shlb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x28U);
      }
   }
   else
   {
      printf("shlb_4 ... failed\n");
   }

   return;
}

static void shlb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "shlb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

      if (result0.ub[0] == 0x28U )
      {
         printf("shlb_5 ... ok\n");
      }
      else
      {
         printf("shlb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x28U);
      }
   }
   else
   {
      printf("shlb_5 ... failed\n");
   }

   return;
}

static void shlb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shlb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ub[0] == 0x28U )
      {
         printf("shlb_6 ... ok\n");
      }
      else
      {
         printf("shlb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x28U);
      }
   }
   else
   {
      printf("shlb_6 ... failed\n");
   }

   return;
}

static void shlw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "shlw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0xe194 )
      {
         printf("shlw_1 ... ok\n");
      }
      else
      {
         printf("shlw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe194);
      }
   }
   else
   {
      printf("shlw_1 ... failed\n");
   }

   return;
}

static void shlw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shlw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.uw[0] == 0xe194 )
      {
         printf("shlw_2 ... ok\n");
      }
      else
      {
         printf("shlw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe194);
      }
   }
   else
   {
      printf("shlw_2 ... failed\n");
   }

   return;
}

static void shlw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "shlw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x0ca0 )
      {
         printf("shlw_3 ... ok\n");
      }
      else
      {
         printf("shlw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca0);
      }
   }
   else
   {
      printf("shlw_3 ... failed\n");
   }

   return;
}

static void shlw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shlw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x0ca0 )
      {
         printf("shlw_4 ... ok\n");
      }
      else
      {
         printf("shlw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca0);
      }
   }
   else
   {
      printf("shlw_4 ... failed\n");
   }

   return;
}

static void shlw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "shlw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0x0ca0 )
      {
         printf("shlw_5 ... ok\n");
      }
      else
      {
         printf("shlw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca0);
      }
   }
   else
   {
      printf("shlw_5 ... failed\n");
   }

   return;
}

static void shlw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shlw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.uw[0] == 0x0ca0 )
      {
         printf("shlw_6 ... ok\n");
      }
      else
      {
         printf("shlw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0ca0);
      }
   }
   else
   {
      printf("shlw_6 ... failed\n");
   }

   return;
}

static void shll_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "shll %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0xfe01e194UL )
      {
         printf("shll_1 ... ok\n");
      }
      else
      {
         printf("shll_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e194UL);
      }
   }
   else
   {
      printf("shll_1 ... failed\n");
   }

   return;
}

static void shll_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shll %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ud[0] == 0xfe01e194UL )
      {
         printf("shll_2 ... ok\n");
      }
      else
      {
         printf("shll_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e194UL);
      }
   }
   else
   {
      printf("shll_2 ... failed\n");
   }

   return;
}

static void shll_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "shll $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x00f0ca00UL )
      {
         printf("shll_3 ... ok\n");
      }
      else
      {
         printf("shll_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca00UL);
      }
   }
   else
   {
      printf("shll_3 ... failed\n");
   }

   return;
}

static void shll_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shll $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x00f0ca00UL )
      {
         printf("shll_4 ... ok\n");
      }
      else
      {
         printf("shll_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca00UL);
      }
   }
   else
   {
      printf("shll_4 ... failed\n");
   }

   return;
}

static void shll_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "shll %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0x00f0ca00UL )
      {
         printf("shll_5 ... ok\n");
      }
      else
      {
         printf("shll_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca00UL);
      }
   }
   else
   {
      printf("shll_5 ... failed\n");
   }

   return;
}

static void shll_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shll %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ud[0] == 0x00f0ca00UL )
      {
         printf("shll_6 ... ok\n");
      }
      else
      {
         printf("shll_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0ca00UL);
      }
   }
   else
   {
      printf("shll_6 ... failed\n");
   }

   return;
}

static void shrb_1(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "shrb %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x65U )
      {
         printf("shrb_1 ... ok\n");
      }
      else
      {
         printf("shrb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x65U);
      }
   }
   else
   {
      printf("shrb_1 ... failed\n");
   }

   return;
}

static void shrb_2(void)
{
   reg8_t arg0 = { .ub = { 0xcaU } };
   reg8_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrb %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ub[0] == 0x65U )
      {
         printf("shrb_2 ... ok\n");
      }
      else
      {
         printf("shrb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x65U);
      }
   }
   else
   {
      printf("shrb_2 ... failed\n");
   }

   return;
}

static void shrb_3(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "shrb $2, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x32U )
      {
         printf("shrb_3 ... ok\n");
      }
      else
      {
         printf("shrb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
      }
   }
   else
   {
      printf("shrb_3 ... failed\n");
   }

   return;
}

static void shrb_4(void)
{
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrb $2, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 0x32U )
      {
         printf("shrb_4 ... ok\n");
      }
      else
      {
         printf("shrb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
      }
   }
   else
   {
      printf("shrb_4 ... failed\n");
   }

   return;
}

static void shrb_5(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movb %1, %%al\n"
         "shrb %%cl, %%al\n"
         "movb %%al, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "al"
      );

      if (result0.ub[0] == 0x32U )
      {
         printf("shrb_5 ... ok\n");
      }
      else
      {
         printf("shrb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
      }
   }
   else
   {
      printf("shrb_5 ... failed\n");
   }

   return;
}

static void shrb_6(void)
{
   reg8_t arg0 = { .ub = { 2U } };
   reg8_t arg1 = { .ub = { 0xcaU } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shrb %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ub[0] == 0x32U )
      {
         printf("shrb_6 ... ok\n");
      }
      else
      {
         printf("shrb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x32U);
      }
   }
   else
   {
      printf("shrb_6 ... failed\n");
   }

   return;
}

static void shrw_1(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "shrw %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrw_1 ... ok\n");
      }
      else
      {
         printf("shrw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrw_1 ... failed\n");
   }

   return;
}

static void shrw_2(void)
{
   reg16_t arg0 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrw %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrw_2 ... ok\n");
      }
      else
      {
         printf("shrw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrw_2 ... failed\n");
   }

   return;
}

static void shrw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "shrw $4, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x0f0c )
      {
         printf("shrw_3 ... ok\n");
      }
      else
      {
         printf("shrw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0f0c);
      }
   }
   else
   {
      printf("shrw_3 ... failed\n");
   }

   return;
}

static void shrw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrw $4, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x0f0c )
      {
         printf("shrw_4 ... ok\n");
      }
      else
      {
         printf("shrw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0f0c);
      }
   }
   else
   {
      printf("shrw_4 ... failed\n");
   }

   return;
}

static void shrw_5(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "shrw %%cl, %%ax\n"
         "movw %%ax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0x0f0c )
      {
         printf("shrw_5 ... ok\n");
      }
      else
      {
         printf("shrw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0f0c);
      }
   }
   else
   {
      printf("shrw_5 ... failed\n");
   }

   return;
}

static void shrw_6(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shrw %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.uw[0] == 0x0f0c )
      {
         printf("shrw_6 ... ok\n");
      }
      else
      {
         printf("shrw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0f0c);
      }
   }
   else
   {
      printf("shrw_6 ... failed\n");
   }

   return;
}

static void shrl_1(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "shrl %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg0), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrl_1 ... ok\n");
      }
      else
      {
         printf("shrl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrl_1 ... failed\n");
   }

   return;
}

static void shrl_2(void)
{
   reg32_t arg0 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg0), "m" (state[0])

      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrl_2 ... ok\n");
      }
      else
      {
         printf("shrl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrl_2 ... failed\n");
   }

   return;
}

static void shrl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "shrl $8, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x00ff00f0UL )
      {
         printf("shrl_3 ... ok\n");
      }
      else
      {
         printf("shrl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00ff00f0UL);
      }
   }
   else
   {
      printf("shrl_3 ... failed\n");
   }

   return;
}

static void shrl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "shrl $8, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x00ff00f0UL )
      {
         printf("shrl_4 ... ok\n");
      }
      else
      {
         printf("shrl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00ff00f0UL);
      }
   }
   else
   {
      printf("shrl_4 ... failed\n");
   }

   return;
}

static void shrl_5(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "shrl %%cl, %%eax\n"
         "movl %%eax, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0x00ff00f0UL )
      {
         printf("shrl_5 ... ok\n");
      }
      else
      {
         printf("shrl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00ff00f0UL);
      }
   }
   else
   {
      printf("shrl_5 ... failed\n");
   }

   return;
}

static void shrl_6(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%cl\n"
         "shrl %%cl, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "cl"
      );

      if (result0.ud[0] == 0x00ff00f0UL )
      {
         printf("shrl_6 ... ok\n");
      }
      else
      {
         printf("shrl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00ff00f0UL);
      }
   }
   else
   {
      printf("shrl_6 ... failed\n");
   }

   return;
}

static void shldw_1(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "shldw $1, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0xe195 )
      {
         printf("shldw_1 ... ok\n");
      }
      else
      {
         printf("shldw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe195);
      }
   }
   else
   {
      printf("shldw_1 ... failed\n");
   }

   return;
}

static void shldw_2(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "shldw $1, %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0xe195 )
      {
         printf("shldw_2 ... ok\n");
      }
      else
      {
         printf("shldw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe195);
      }
   }
   else
   {
      printf("shldw_2 ... failed\n");
   }

   return;
}

static void shldw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "shldw $4, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0x0caf )
      {
         printf("shldw_3 ... ok\n");
      }
      else
      {
         printf("shldw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0caf);
      }
   }
   else
   {
      printf("shldw_3 ... failed\n");
   }

   return;
}

static void shldw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "shldw $4, %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x0caf )
      {
         printf("shldw_4 ... ok\n");
      }
      else
      {
         printf("shldw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0caf);
      }
   }
   else
   {
      printf("shldw_4 ... failed\n");
   }

   return;
}

static void shldw_5(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "shldw %%cl, %%ax, %%bx\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "ax", "bx"
      );

      if (result0.uw[0] == 0xe195 )
      {
         printf("shldw_5 ... ok\n");
      }
      else
      {
         printf("shldw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe195);
      }
   }
   else
   {
      printf("shldw_5 ... failed\n");
   }

   return;
}

static void shldw_6(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movw %2, %%ax\n"
         "shldw %%cl, %%ax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0xe195 )
      {
         printf("shldw_6 ... ok\n");
      }
      else
      {
         printf("shldw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xe195);
      }
   }
   else
   {
      printf("shldw_6 ... failed\n");
   }

   return;
}

static void shldw_7(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "shldw %%cl, %%ax, %%bx\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "ax", "bx"
      );

      if (result0.uw[0] == 0x0caf )
      {
         printf("shldw_7 ... ok\n");
      }
      else
      {
         printf("shldw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0caf);
      }
   }
   else
   {
      printf("shldw_7 ... failed\n");
   }

   return;
}

static void shldw_8(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movw %2, %%ax\n"
         "shldw %%cl, %%ax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0x0caf )
      {
         printf("shldw_8 ... ok\n");
      }
      else
      {
         printf("shldw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x0caf);
      }
   }
   else
   {
      printf("shldw_8 ... failed\n");
   }

   return;
}

static void shldl_1(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "shldl $1, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0xfe01e195UL )
      {
         printf("shldl_1 ... ok\n");
      }
      else
      {
         printf("shldl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e195UL);
      }
   }
   else
   {
      printf("shldl_1 ... failed\n");
   }

   return;
}

static void shldl_2(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "shldl $1, %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0xfe01e195UL )
      {
         printf("shldl_2 ... ok\n");
      }
      else
      {
         printf("shldl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e195UL);
      }
   }
   else
   {
      printf("shldl_2 ... failed\n");
   }

   return;
}

static void shldl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "shldl $8, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0x00f0caffUL )
      {
         printf("shldl_3 ... ok\n");
      }
      else
      {
         printf("shldl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0caffUL);
      }
   }
   else
   {
      printf("shldl_3 ... failed\n");
   }

   return;
}

static void shldl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "shldl $8, %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x00f0caffUL )
      {
         printf("shldl_4 ... ok\n");
      }
      else
      {
         printf("shldl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0caffUL);
      }
   }
   else
   {
      printf("shldl_4 ... failed\n");
   }

   return;
}

static void shldl_5(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "shldl %%cl, %%eax, %%ebx\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "eax", "ebx"
      );

      if (result0.ud[0] == 0xfe01e195UL )
      {
         printf("shldl_5 ... ok\n");
      }
      else
      {
         printf("shldl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e195UL);
      }
   }
   else
   {
      printf("shldl_5 ... failed\n");
   }

   return;
}

static void shldl_6(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movl %2, %%eax\n"
         "shldl %%cl, %%eax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0xfe01e195UL )
      {
         printf("shldl_6 ... ok\n");
      }
      else
      {
         printf("shldl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xfe01e195UL);
      }
   }
   else
   {
      printf("shldl_6 ... failed\n");
   }

   return;
}

static void shldl_7(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "shldl %%cl, %%eax, %%ebx\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "eax", "ebx"
      );

      if (result0.ud[0] == 0x00f0caffUL )
      {
         printf("shldl_7 ... ok\n");
      }
      else
      {
         printf("shldl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0caffUL);
      }
   }
   else
   {
      printf("shldl_7 ... failed\n");
   }

   return;
}

static void shldl_8(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movl %2, %%eax\n"
         "shldl %%cl, %%eax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0x00f0caffUL )
      {
         printf("shldl_8 ... ok\n");
      }
      else
      {
         printf("shldl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x00f0caffUL);
      }
   }
   else
   {
      printf("shldl_8 ... failed\n");
   }

   return;
}

static void shrdw_1(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "shrdw $1, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrdw_1 ... ok\n");
      }
      else
      {
         printf("shrdw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrdw_1 ... failed\n");
   }

   return;
}

static void shrdw_2(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "shrdw $1, %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrdw_2 ... ok\n");
      }
      else
      {
         printf("shrdw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrdw_2 ... failed\n");
   }

   return;
}

static void shrdw_3(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "shrdw $4, %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0xaf0c )
      {
         printf("shrdw_3 ... ok\n");
      }
      else
      {
         printf("shrdw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xaf0c);
      }
   }
   else
   {
      printf("shrdw_3 ... failed\n");
   }

   return;
}

static void shrdw_4(void)
{
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "shrdw $4, %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0xaf0c )
      {
         printf("shrdw_4 ... ok\n");
      }
      else
      {
         printf("shrdw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xaf0c);
      }
   }
   else
   {
      printf("shrdw_4 ... failed\n");
   }

   return;
}

static void shrdw_5(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "shrdw %%cl, %%ax, %%bx\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "ax", "bx"
      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrdw_5 ... ok\n");
      }
      else
      {
         printf("shrdw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrdw_5 ... failed\n");
   }

   return;
}

static void shrdw_6(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movw %2, %%ax\n"
         "shrdw %%cl, %%ax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0x7865 )
      {
         printf("shrdw_6 ... ok\n");
      }
      else
      {
         printf("shrdw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x7865);
      }
   }
   else
   {
      printf("shrdw_6 ... failed\n");
   }

   return;
}

static void shrdw_7(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movw %1, %%ax\n"
         "movw %2, %%bx\n"
         "shrdw %%cl, %%ax, %%bx\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "ax", "bx"
      );

      if (result0.uw[0] == 0xaf0c )
      {
         printf("shrdw_7 ... ok\n");
      }
      else
      {
         printf("shrdw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xaf0c);
      }
   }
   else
   {
      printf("shrdw_7 ... failed\n");
   }

   return;
}

static void shrdw_8(void)
{
   reg8_t arg0 = { .ub = { 4U } };
   reg16_t arg1 = { .uw = { 0xf0ca } };
   reg16_t arg2 = { .uw = { 0xf0ca } };
   reg16_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movw %2, %%ax\n"
         "shrdw %%cl, %%ax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "ax"
      );

      if (result0.uw[0] == 0xaf0c )
      {
         printf("shrdw_8 ... ok\n");
      }
      else
      {
         printf("shrdw_8 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0xaf0c);
      }
   }
   else
   {
      printf("shrdw_8 ... failed\n");
   }

   return;
}

static void shrdl_1(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "shrdl $1, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrdl_1 ... ok\n");
      }
      else
      {
         printf("shrdl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrdl_1 ... failed\n");
   }

   return;
}

static void shrdl_2(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "shrdl $1, %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrdl_2 ... ok\n");
      }
      else
      {
         printf("shrdl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrdl_2 ... failed\n");
   }

   return;
}

static void shrdl_3(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "shrdl $8, %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0xcaff00f0UL )
      {
         printf("shrdl_3 ... ok\n");
      }
      else
      {
         printf("shrdl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xcaff00f0UL);
      }
   }
   else
   {
      printf("shrdl_3 ... failed\n");
   }

   return;
}

static void shrdl_4(void)
{
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "shrdl $8, %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg1), "m" (arg2), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0xcaff00f0UL )
      {
         printf("shrdl_4 ... ok\n");
      }
      else
      {
         printf("shrdl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xcaff00f0UL);
      }
   }
   else
   {
      printf("shrdl_4 ... failed\n");
   }

   return;
}

static void shrdl_5(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "shrdl %%cl, %%eax, %%ebx\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "eax", "ebx"
      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrdl_5 ... ok\n");
      }
      else
      {
         printf("shrdl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrdl_5 ... failed\n");
   }

   return;
}

static void shrdl_6(void)
{
   reg8_t arg0 = { .ub = { 1U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movl %2, %%eax\n"
         "shrdl %%cl, %%eax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0x7f807865UL )
      {
         printf("shrdl_6 ... ok\n");
      }
      else
      {
         printf("shrdl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x7f807865UL);
      }
   }
   else
   {
      printf("shrdl_6 ... failed\n");
   }

   return;
}

static void shrdl_7(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%cl\n"
         "movl %1, %%eax\n"
         "movl %2, %%ebx\n"
         "shrdl %%cl, %%eax, %%ebx\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (result0), "m" (state[0])
         : "cl", "eax", "ebx"
      );

      if (result0.ud[0] == 0xcaff00f0UL )
      {
         printf("shrdl_7 ... ok\n");
      }
      else
      {
         printf("shrdl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xcaff00f0UL);
      }
   }
   else
   {
      printf("shrdl_7 ... failed\n");
   }

   return;
}

static void shrdl_8(void)
{
   reg8_t arg0 = { .ub = { 8U } };
   reg32_t arg1 = { .ud = { 0xff00f0caUL } };
   reg32_t arg2 = { .ud = { 0xff00f0caUL } };
   reg32_t result0 = arg2;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%cl\n"
         "movl %2, %%eax\n"
         "shrdl %%cl, %%eax, %0\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (arg2), "m" (state[0])
         : "cl", "eax"
      );

      if (result0.ud[0] == 0xcaff00f0UL )
      {
         printf("shrdl_8 ... ok\n");
      }
      else
      {
         printf("shrdl_8 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0xcaff00f0UL);
      }
   }
   else
   {
      printf("shrdl_8 ... failed\n");
   }

   return;
}

static void stc_1(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "stc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("stc_1 ... ok\n");
      }
      else
      {
         printf("stc_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("stc_1 ... failed\n");
   }

   return;
}

static void stc_2(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffffe, (%%esp)\n"
         "orl $0x00000001, (%%esp)\n"
         "popfl\n"
         "stc\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000001UL) == 0x00000001UL )
      {
         printf("stc_2 ... ok\n");
      }
      else
      {
         printf("stc_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000001UL, result0.ud[0] & 0x00000001UL, 0x00000001UL);
      }
   }
   else
   {
      printf("stc_2 ... failed\n");
   }

   return;
}

static void std_1(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffbff, (%%esp)\n"
         "orl $0x00000000, (%%esp)\n"
         "popfl\n"
         "std\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000400UL) == 0x00000400UL )
      {
         printf("std_1 ... ok\n");
      }
      else
      {
         printf("std_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000400UL, result0.ud[0] & 0x00000400UL, 0x00000400UL);
      }
   }
   else
   {
      printf("std_1 ... failed\n");
   }

   return;
}

static void std_2(void)
{
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %1\n"
         "pushfl\n"
         "andl $0xfffffbff, (%%esp)\n"
         "orl $0x00000400, (%%esp)\n"
         "popfl\n"
         "std\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %1\n"
         : "=m" (result0)
         : "m" (state[0])

      );

      if ((result0.ud[0] & 0x00000400UL) == 0x00000400UL )
      {
         printf("std_2 ... ok\n");
      }
      else
      {
         printf("std_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x00000400UL, result0.ud[0] & 0x00000400UL, 0x00000400UL);
      }
   }
   else
   {
      printf("std_2 ... failed\n");
   }

   return;
}

static void subb_1(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "subb $12, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_1 ... ok\n");
      }
      else
      {
         printf("subb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_1 ... failed\n");
   }

   return;
}

static void subb_2(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "subb $12, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_2 ... ok\n");
      }
      else
      {
         printf("subb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_2 ... failed\n");
   }

   return;
}

static void subb_3(void)
{
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "subb $12, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_3 ... ok\n");
      }
      else
      {
         printf("subb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_3 ... failed\n");
   }

   return;
}

static void subb_4(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "subb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_4 ... ok\n");
      }
      else
      {
         printf("subb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_4 ... failed\n");
   }

   return;
}

static void subb_5(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "subb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_5 ... ok\n");
      }
      else
      {
         printf("subb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_5 ... failed\n");
   }

   return;
}

static void subb_6(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "subb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

      if (result0.ub[0] == 22U )
      {
         printf("subb_6 ... ok\n");
      }
      else
      {
         printf("subb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 22U);
      }
   }
   else
   {
      printf("subb_6 ... failed\n");
   }

   return;
}

static void subw_1(void)
{
   reg16_t arg1 = { .uw = { 3456 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "subw $12, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 3444 )
      {
         printf("subw_1 ... ok\n");
      }
      else
      {
         printf("subw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 3444);
      }
   }
   else
   {
      printf("subw_1 ... failed\n");
   }

   return;
}

static void subw_2(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "subw $1234, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_2 ... ok\n");
      }
      else
      {
         printf("subw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_2 ... failed\n");
   }

   return;
}

static void subw_3(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%bx\n"
         "subw $1234, %%bx\n"
         "movw %%bx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_3 ... ok\n");
      }
      else
      {
         printf("subw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_3 ... failed\n");
   }

   return;
}

static void subw_4(void)
{
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "subw $1234, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_4 ... ok\n");
      }
      else
      {
         printf("subw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_4 ... failed\n");
   }

   return;
}

static void subw_5(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "subw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_5 ... ok\n");
      }
      else
      {
         printf("subw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_5 ... failed\n");
   }

   return;
}

static void subw_6(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "subw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_6 ... ok\n");
      }
      else
      {
         printf("subw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_6 ... failed\n");
   }

   return;
}

static void subw_7(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "subw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 4444 )
      {
         printf("subw_7 ... ok\n");
      }
      else
      {
         printf("subw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 4444);
      }
   }
   else
   {
      printf("subw_7 ... failed\n");
   }

   return;
}

static void subl_1(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "subl $12, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 87654309UL )
      {
         printf("subl_1 ... ok\n");
      }
      else
      {
         printf("subl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654309UL);
      }
   }
   else
   {
      printf("subl_1 ... failed\n");
   }

   return;
}

static void subl_2(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "subl $12345678, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_2 ... ok\n");
      }
      else
      {
         printf("subl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_2 ... failed\n");
   }

   return;
}

static void subl_3(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "subl $12345678, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_3 ... ok\n");
      }
      else
      {
         printf("subl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_3 ... failed\n");
   }

   return;
}

static void subl_4(void)
{
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%ebx\n"
         "subl $12345678, %%ebx\n"
         "movl %%ebx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_4 ... ok\n");
      }
      else
      {
         printf("subl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_4 ... failed\n");
   }

   return;
}

static void subl_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "subl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_5 ... ok\n");
      }
      else
      {
         printf("subl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_5 ... failed\n");
   }

   return;
}

static void subl_6(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "subl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_6 ... ok\n");
      }
      else
      {
         printf("subl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_6 ... failed\n");
   }

   return;
}

static void subl_7(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "subl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 75308643UL )
      {
         printf("subl_7 ... ok\n");
      }
      else
      {
         printf("subl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 75308643UL);
      }
   }
   else
   {
      printf("subl_7 ... failed\n");
   }

   return;
}

static void testb_1(void)
{
   reg8_t arg1 = { .ub = { 0x1aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testb_1 ... ok\n");
      }
      else
      {
         printf("testb_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testb_1 ... failed\n");
   }

   return;
}

static void testb_2(void)
{
   reg8_t arg1 = { .ub = { 0x5aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testb $0x5a, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testb_2 ... ok\n");
      }
      else
      {
         printf("testb_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testb_2 ... failed\n");
   }

   return;
}

static void testb_3(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testb_3 ... ok\n");
      }
      else
      {
         printf("testb_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testb_3 ... failed\n");
   }

   return;
}

static void testb_4(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testb $0xa1, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testb_4 ... ok\n");
      }
      else
      {
         printf("testb_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testb_4 ... failed\n");
   }

   return;
}

static void testb_5(void)
{
   reg8_t arg1 = { .ub = { 0xa5U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testb $0xa5, %%al\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testb_5 ... ok\n");
      }
      else
      {
         printf("testb_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testb_5 ... failed\n");
   }

   return;
}

static void testb_6(void)
{
   reg8_t arg1 = { .ub = { 0x1aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testb_6 ... ok\n");
      }
      else
      {
         printf("testb_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testb_6 ... failed\n");
   }

   return;
}

static void testb_7(void)
{
   reg8_t arg1 = { .ub = { 0x5aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testb $0x5a, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testb_7 ... ok\n");
      }
      else
      {
         printf("testb_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testb_7 ... failed\n");
   }

   return;
}

static void testb_8(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testb_8 ... ok\n");
      }
      else
      {
         printf("testb_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testb_8 ... failed\n");
   }

   return;
}

static void testb_9(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testb $0xa1, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testb_9 ... ok\n");
      }
      else
      {
         printf("testb_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testb_9 ... failed\n");
   }

   return;
}

static void testb_10(void)
{
   reg8_t arg1 = { .ub = { 0xa5U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %1, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testb $0xa5, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testb_10 ... ok\n");
      }
      else
      {
         printf("testb_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testb_10 ... failed\n");
   }

   return;
}

static void testb_11(void)
{
   reg8_t arg1 = { .ub = { 0x1aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testb_11 ... ok\n");
      }
      else
      {
         printf("testb_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testb_11 ... failed\n");
   }

   return;
}

static void testb_12(void)
{
   reg8_t arg1 = { .ub = { 0x5aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testb $0x5a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testb_12 ... ok\n");
      }
      else
      {
         printf("testb_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testb_12 ... failed\n");
   }

   return;
}

static void testb_13(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testb $0x1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testb_13 ... ok\n");
      }
      else
      {
         printf("testb_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testb_13 ... failed\n");
   }

   return;
}

static void testb_14(void)
{
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testb $0xa1, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testb_14 ... ok\n");
      }
      else
      {
         printf("testb_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testb_14 ... failed\n");
   }

   return;
}

static void testb_15(void)
{
   reg8_t arg1 = { .ub = { 0xa5U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testb $0xa5, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testb_15 ... ok\n");
      }
      else
      {
         printf("testb_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testb_15 ... failed\n");
   }

   return;
}

static void testb_16(void)
{
   reg8_t arg0 = { .ub = { 0x1aU } };
   reg8_t arg1 = { .ub = { 0x1aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testb_16 ... ok\n");
      }
      else
      {
         printf("testb_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testb_16 ... failed\n");
   }

   return;
}

static void testb_17(void)
{
   reg8_t arg0 = { .ub = { 0x5aU } };
   reg8_t arg1 = { .ub = { 0x5aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testb_17 ... ok\n");
      }
      else
      {
         printf("testb_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testb_17 ... failed\n");
   }

   return;
}

static void testb_18(void)
{
   reg8_t arg0 = { .ub = { 0x1aU } };
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testb_18 ... ok\n");
      }
      else
      {
         printf("testb_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testb_18 ... failed\n");
   }

   return;
}

static void testb_19(void)
{
   reg8_t arg0 = { .ub = { 0xa1U } };
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testb_19 ... ok\n");
      }
      else
      {
         printf("testb_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testb_19 ... failed\n");
   }

   return;
}

static void testb_20(void)
{
   reg8_t arg0 = { .ub = { 0xa5U } };
   reg8_t arg1 = { .ub = { 0xa5U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "movb %2, %%bl\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testb %%al, %%bl\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al", "bl"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testb_20 ... ok\n");
      }
      else
      {
         printf("testb_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testb_20 ... failed\n");
   }

   return;
}

static void testb_21(void)
{
   reg8_t arg0 = { .ub = { 0x1aU } };
   reg8_t arg1 = { .ub = { 0x1aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testb_21 ... ok\n");
      }
      else
      {
         printf("testb_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testb_21 ... failed\n");
   }

   return;
}

static void testb_22(void)
{
   reg8_t arg0 = { .ub = { 0x5aU } };
   reg8_t arg1 = { .ub = { 0x5aU } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testb_22 ... ok\n");
      }
      else
      {
         printf("testb_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testb_22 ... failed\n");
   }

   return;
}

static void testb_23(void)
{
   reg8_t arg0 = { .ub = { 0x1aU } };
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testb_23 ... ok\n");
      }
      else
      {
         printf("testb_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testb_23 ... failed\n");
   }

   return;
}

static void testb_24(void)
{
   reg8_t arg0 = { .ub = { 0xa1U } };
   reg8_t arg1 = { .ub = { 0xa1U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testb_24 ... ok\n");
      }
      else
      {
         printf("testb_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testb_24 ... failed\n");
   }

   return;
}

static void testb_25(void)
{
   reg8_t arg0 = { .ub = { 0xa5U } };
   reg8_t arg1 = { .ub = { 0xa5U } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testb %%al, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testb_25 ... ok\n");
      }
      else
      {
         printf("testb_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testb_25 ... failed\n");
   }

   return;
}

static void testw_1(void)
{
   reg16_t arg1 = { .uw = { 0x1a1a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testw_1 ... ok\n");
      }
      else
      {
         printf("testw_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testw_1 ... failed\n");
   }

   return;
}

static void testw_2(void)
{
   reg16_t arg1 = { .uw = { 0x5a5a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testw $0x5a5a, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testw_2 ... ok\n");
      }
      else
      {
         printf("testw_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testw_2 ... failed\n");
   }

   return;
}

static void testw_3(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testw_3 ... ok\n");
      }
      else
      {
         printf("testw_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testw_3 ... failed\n");
   }

   return;
}

static void testw_4(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testw $0xa1a1, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testw_4 ... ok\n");
      }
      else
      {
         printf("testw_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testw_4 ... failed\n");
   }

   return;
}

static void testw_5(void)
{
   reg16_t arg1 = { .uw = { 0xa5a5 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testw $0xa5a5, %%ax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testw_5 ... ok\n");
      }
      else
      {
         printf("testw_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testw_5 ... failed\n");
   }

   return;
}

static void testw_6(void)
{
   reg16_t arg1 = { .uw = { 0x1a1a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testw_6 ... ok\n");
      }
      else
      {
         printf("testw_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testw_6 ... failed\n");
   }

   return;
}

static void testw_7(void)
{
   reg16_t arg1 = { .uw = { 0x5a5a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testw $0x5a5a, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testw_7 ... ok\n");
      }
      else
      {
         printf("testw_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testw_7 ... failed\n");
   }

   return;
}

static void testw_8(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testw_8 ... ok\n");
      }
      else
      {
         printf("testw_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testw_8 ... failed\n");
   }

   return;
}

static void testw_9(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testw $0xa1a1, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testw_9 ... ok\n");
      }
      else
      {
         printf("testw_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testw_9 ... failed\n");
   }

   return;
}

static void testw_10(void)
{
   reg16_t arg1 = { .uw = { 0xa5a5 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %1, %%bx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testw $0xa5a5, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testw_10 ... ok\n");
      }
      else
      {
         printf("testw_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testw_10 ... failed\n");
   }

   return;
}

static void testw_11(void)
{
   reg16_t arg1 = { .uw = { 0x1a1a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testw_11 ... ok\n");
      }
      else
      {
         printf("testw_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testw_11 ... failed\n");
   }

   return;
}

static void testw_12(void)
{
   reg16_t arg1 = { .uw = { 0x5a5a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testw $0x5a5a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testw_12 ... ok\n");
      }
      else
      {
         printf("testw_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testw_12 ... failed\n");
   }

   return;
}

static void testw_13(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testw $0x1a1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testw_13 ... ok\n");
      }
      else
      {
         printf("testw_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testw_13 ... failed\n");
   }

   return;
}

static void testw_14(void)
{
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testw $0xa1a1, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testw_14 ... ok\n");
      }
      else
      {
         printf("testw_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testw_14 ... failed\n");
   }

   return;
}

static void testw_15(void)
{
   reg16_t arg1 = { .uw = { 0xa5a5 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testw $0xa5a5, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testw_15 ... ok\n");
      }
      else
      {
         printf("testw_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testw_15 ... failed\n");
   }

   return;
}

static void testw_16(void)
{
   reg16_t arg0 = { .uw = { 0x1a1a } };
   reg16_t arg1 = { .uw = { 0x1a1a } };
   reg32_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 $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testw_16 ... ok\n");
      }
      else
      {
         printf("testw_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testw_16 ... failed\n");
   }

   return;
}

static void testw_17(void)
{
   reg16_t arg0 = { .uw = { 0x5a5a } };
   reg16_t arg1 = { .uw = { 0x5a5a } };
   reg32_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 $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testw_17 ... ok\n");
      }
      else
      {
         printf("testw_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testw_17 ... failed\n");
   }

   return;
}

static void testw_18(void)
{
   reg16_t arg0 = { .uw = { 0x1a1a } };
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testw_18 ... ok\n");
      }
      else
      {
         printf("testw_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testw_18 ... failed\n");
   }

   return;
}

static void testw_19(void)
{
   reg16_t arg0 = { .uw = { 0xa1a1 } };
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testw_19 ... ok\n");
      }
      else
      {
         printf("testw_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testw_19 ... failed\n");
   }

   return;
}

static void testw_20(void)
{
   reg16_t arg0 = { .uw = { 0xa5a5 } };
   reg16_t arg1 = { .uw = { 0xa5a5 } };
   reg32_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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %%bx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax", "bx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testw_20 ... ok\n");
      }
      else
      {
         printf("testw_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testw_20 ... failed\n");
   }

   return;
}

static void testw_21(void)
{
   reg16_t arg0 = { .uw = { 0x1a1a } };
   reg16_t arg1 = { .uw = { 0x1a1a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testw_21 ... ok\n");
      }
      else
      {
         printf("testw_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testw_21 ... failed\n");
   }

   return;
}

static void testw_22(void)
{
   reg16_t arg0 = { .uw = { 0x5a5a } };
   reg16_t arg1 = { .uw = { 0x5a5a } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testw_22 ... ok\n");
      }
      else
      {
         printf("testw_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testw_22 ... failed\n");
   }

   return;
}

static void testw_23(void)
{
   reg16_t arg0 = { .uw = { 0x1a1a } };
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testw_23 ... ok\n");
      }
      else
      {
         printf("testw_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testw_23 ... failed\n");
   }

   return;
}

static void testw_24(void)
{
   reg16_t arg0 = { .uw = { 0xa1a1 } };
   reg16_t arg1 = { .uw = { 0xa1a1 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testw_24 ... ok\n");
      }
      else
      {
         printf("testw_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testw_24 ... failed\n");
   }

   return;
}

static void testw_25(void)
{
   reg16_t arg0 = { .uw = { 0xa5a5 } };
   reg16_t arg1 = { .uw = { 0xa5a5 } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testw %%ax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testw_25 ... ok\n");
      }
      else
      {
         printf("testw_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testw_25 ... failed\n");
   }

   return;
}

static void testl_1(void)
{
   reg32_t arg1 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testl_1 ... ok\n");
      }
      else
      {
         printf("testl_1 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testl_1 ... failed\n");
   }

   return;
}

static void testl_2(void)
{
   reg32_t arg1 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testl $0x5a5a5a5a, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testl_2 ... ok\n");
      }
      else
      {
         printf("testl_2 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testl_2 ... failed\n");
   }

   return;
}

static void testl_3(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testl_3 ... ok\n");
      }
      else
      {
         printf("testl_3 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testl_3 ... failed\n");
   }

   return;
}

static void testl_4(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testl $0xa1a1a1a1, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testl_4 ... ok\n");
      }
      else
      {
         printf("testl_4 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testl_4 ... failed\n");
   }

   return;
}

static void testl_5(void)
{
   reg32_t arg1 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testl $0xa5a5a5a5, %%eax\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testl_5 ... ok\n");
      }
      else
      {
         printf("testl_5 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testl_5 ... failed\n");
   }

   return;
}

static void testl_6(void)
{
   reg32_t arg1 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testl_6 ... ok\n");
      }
      else
      {
         printf("testl_6 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testl_6 ... failed\n");
   }

   return;
}

static void testl_7(void)
{
   reg32_t arg1 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testl $0x5a5a5a5a, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testl_7 ... ok\n");
      }
      else
      {
         printf("testl_7 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testl_7 ... failed\n");
   }

   return;
}

static void testl_8(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testl_8 ... ok\n");
      }
      else
      {
         printf("testl_8 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testl_8 ... failed\n");
   }

   return;
}

static void testl_9(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testl $0xa1a1a1a1, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testl_9 ... ok\n");
      }
      else
      {
         printf("testl_9 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testl_9 ... failed\n");
   }

   return;
}

static void testl_10(void)
{
   reg32_t arg1 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %1, %%ebx\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testl $0xa5a5a5a5, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])
         : "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testl_10 ... ok\n");
      }
      else
      {
         printf("testl_10 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testl_10 ... failed\n");
   }

   return;
}

static void testl_11(void)
{
   reg32_t arg1 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testl_11 ... ok\n");
      }
      else
      {
         printf("testl_11 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testl_11 ... failed\n");
   }

   return;
}

static void testl_12(void)
{
   reg32_t arg1 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testl $0x5a5a5a5a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testl_12 ... ok\n");
      }
      else
      {
         printf("testl_12 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testl_12 ... failed\n");
   }

   return;
}

static void testl_13(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testl $0x1a1a1a1a, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testl_13 ... ok\n");
      }
      else
      {
         printf("testl_13 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testl_13 ... failed\n");
   }

   return;
}

static void testl_14(void)
{
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testl $0xa1a1a1a1, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testl_14 ... ok\n");
      }
      else
      {
         printf("testl_14 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testl_14 ... failed\n");
   }

   return;
}

static void testl_15(void)
{
   reg32_t arg1 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testl $0xa5a5a5a5, %1\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testl_15 ... ok\n");
      }
      else
      {
         printf("testl_15 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testl_15 ... failed\n");
   }

   return;
}

static void testl_16(void)
{
   reg32_t arg0 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t arg1 = { .ud = { 0x1a1a1a1aUL } };
   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 $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testl_16 ... ok\n");
      }
      else
      {
         printf("testl_16 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testl_16 ... failed\n");
   }

   return;
}

static void testl_17(void)
{
   reg32_t arg0 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t arg1 = { .ud = { 0x5a5a5a5aUL } };
   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 $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testl_17 ... ok\n");
      }
      else
      {
         printf("testl_17 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testl_17 ... failed\n");
   }

   return;
}

static void testl_18(void)
{
   reg32_t arg0 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testl_18 ... ok\n");
      }
      else
      {
         printf("testl_18 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testl_18 ... failed\n");
   }

   return;
}

static void testl_19(void)
{
   reg32_t arg0 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testl_19 ... ok\n");
      }
      else
      {
         printf("testl_19 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testl_19 ... failed\n");
   }

   return;
}

static void testl_20(void)
{
   reg32_t arg0 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t arg1 = { .ud = { 0xa5a5a5a5UL } };
   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 $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %%ebx\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax", "ebx"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testl_20 ... ok\n");
      }
      else
      {
         printf("testl_20 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testl_20 ... failed\n");
   }

   return;
}

static void testl_21(void)
{
   reg32_t arg0 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t arg1 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c5, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000000UL )
      {
         printf("testl_21 ... ok\n");
      }
      else
      {
         printf("testl_21 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000000UL);
      }
   }
   else
   {
      printf("testl_21 ... failed\n");
   }

   return;
}

static void testl_22(void)
{
   reg32_t arg0 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t arg1 = { .ud = { 0x5a5a5a5aUL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x000008c1, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000004UL )
      {
         printf("testl_22 ... ok\n");
      }
      else
      {
         printf("testl_22 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000004UL);
      }
   }
   else
   {
      printf("testl_22 ... failed\n");
   }

   return;
}

static void testl_23(void)
{
   reg32_t arg0 = { .ud = { 0x1a1a1a1aUL } };
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000881, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000044UL )
      {
         printf("testl_23 ... ok\n");
      }
      else
      {
         printf("testl_23 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000044UL);
      }
   }
   else
   {
      printf("testl_23 ... failed\n");
   }

   return;
}

static void testl_24(void)
{
   reg32_t arg0 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t arg1 = { .ud = { 0xa1a1a1a1UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000845, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000080UL )
      {
         printf("testl_24 ... ok\n");
      }
      else
      {
         printf("testl_24 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000080UL);
      }
   }
   else
   {
      printf("testl_24 ... failed\n");
   }

   return;
}

static void testl_25(void)
{
   reg32_t arg0 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t arg1 = { .ud = { 0xa5a5a5a5UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "pushfl\n"
         "andl $0xfffff73a, (%%esp)\n"
         "orl $0x00000841, (%%esp)\n"
         "popfl\n"
         "testl %%eax, %2\n"
         "pushfl\n"
         "popl %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if ((result0.ud[0] & 0x000008c5UL) == 0x00000084UL )
      {
         printf("testl_25 ... ok\n");
      }
      else
      {
         printf("testl_25 ... not ok\n");
         printf("  eflags & 0x%lx = 0x%lx (expected 0x%lx)\n", 0x000008c5UL, result0.ud[0] & 0x000008c5UL, 0x00000084UL);
      }
   }
   else
   {
      printf("testl_25 ... failed\n");
   }

   return;
}

static void xaddb_1(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "xaddb %%al, %%bl\n"
         "movb %%al, %2\n"
         "movb %%bl, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "bl"
      );

      if (result0.ub[0] == 34U &&
          result1.ub[0] == 46U )
      {
         printf("xaddb_1 ... ok\n");
      }
      else
      {
         printf("xaddb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 34U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 46U);
      }
   }
   else
   {
      printf("xaddb_1 ... failed\n");
   }

   return;
}

static void xaddb_2(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   reg8_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%al\n"
         "xaddb %%al, %0\n"
         "movb %%al, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 34U &&
          result1.ub[0] == 46U )
      {
         printf("xaddb_2 ... ok\n");
      }
      else
      {
         printf("xaddb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 34U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 46U);
      }
   }
   else
   {
      printf("xaddb_2 ... failed\n");
   }

   return;
}

static void xaddw_1(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "xaddw %%ax, %%bx\n"
         "movw %%ax, %2\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 6912 )
      {
         printf("xaddw_1 ... ok\n");
      }
      else
      {
         printf("xaddw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 6912);
      }
   }
   else
   {
      printf("xaddw_1 ... failed\n");
   }

   return;
}

static void xaddw_2(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %1, %%ax\n"
         "xaddw %%ax, %0\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 6912 )
      {
         printf("xaddw_2 ... ok\n");
      }
      else
      {
         printf("xaddw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 6912);
      }
   }
   else
   {
      printf("xaddw_2 ... failed\n");
   }

   return;
}

static void xaddl_1(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "xaddl %%eax, %%ebx\n"
         "movl %%eax, %2\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 99999999UL )
      {
         printf("xaddl_1 ... ok\n");
      }
      else
      {
         printf("xaddl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 99999999UL);
      }
   }
   else
   {
      printf("xaddl_1 ... failed\n");
   }

   return;
}

static void xaddl_2(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %1, %%eax\n"
         "xaddl %%eax, %0\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 99999999UL )
      {
         printf("xaddl_2 ... ok\n");
      }
      else
      {
         printf("xaddl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 99999999UL);
      }
   }
   else
   {
      printf("xaddl_2 ... failed\n");
   }

   return;
}

static void xchgb_1(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "xchgb %%al, %%bl\n"
         "movb %%al, %2\n"
         "movb %%bl, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "al", "bl"
      );

      if (result0.ub[0] == 34U &&
          result1.ub[0] == 12U )
      {
         printf("xchgb_1 ... ok\n");
      }
      else
      {
         printf("xchgb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 34U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 12U);
      }
   }
   else
   {
      printf("xchgb_1 ... failed\n");
   }

   return;
}

static void xchgb_2(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0;
   reg8_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %1, %%al\n"
         "xchgb %%al, %0\n"
         "movb %%al, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 34U &&
          result1.ub[0] == 12U )
      {
         printf("xchgb_2 ... ok\n");
      }
      else
      {
         printf("xchgb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 34U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 12U);
      }
   }
   else
   {
      printf("xchgb_2 ... failed\n");
   }

   return;
}

static void xchgb_3(void)
{
   reg8_t arg0 = { .ub = { 12U } };
   reg8_t arg1 = { .ub = { 34U } };
   reg8_t result0 = arg0;
   reg8_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movb %2, %%bl\n"
         "xchgb %0, %%bl\n"
         "movb %%bl, %3\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (result1), "m" (state[0])
         : "bl"
      );

      if (result0.ub[0] == 34U &&
          result1.ub[0] == 12U )
      {
         printf("xchgb_3 ... ok\n");
      }
      else
      {
         printf("xchgb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 34U);
         printf("  result1.ub[0] = %u (expected %u)\n", result1.ub[0], 12U);
      }
   }
   else
   {
      printf("xchgb_3 ... failed\n");
   }

   return;
}

static void xchgw_1(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "xchgw %%ax, %%bx\n"
         "movw %%ax, %2\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 1234 )
      {
         printf("xchgw_1 ... ok\n");
      }
      else
      {
         printf("xchgw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 1234);
      }
   }
   else
   {
      printf("xchgw_1 ... failed\n");
   }

   return;
}

static void xchgw_2(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%bx\n"
         "movw %1, %%ax\n"
         "xchgw %%bx, %%ax\n"
         "movw %%bx, %2\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "bx", "ax"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 1234 )
      {
         printf("xchgw_2 ... ok\n");
      }
      else
      {
         printf("xchgw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 1234);
      }
   }
   else
   {
      printf("xchgw_2 ... failed\n");
   }

   return;
}

static void xchgw_3(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %0, %%ax\n"
         "movw %1, %%cx\n"
         "xchgw %%ax, %%cx\n"
         "movw %%ax, %2\n"
         "movw %%cx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "ax", "cx"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 1234 )
      {
         printf("xchgw_3 ... ok\n");
      }
      else
      {
         printf("xchgw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 1234);
      }
   }
   else
   {
      printf("xchgw_3 ... failed\n");
   }

   return;
}

static void xchgw_4(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0;
   reg16_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %1, %%ax\n"
         "xchgw %%ax, %0\n"
         "movw %%ax, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 1234 )
      {
         printf("xchgw_4 ... ok\n");
      }
      else
      {
         printf("xchgw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 1234);
      }
   }
   else
   {
      printf("xchgw_4 ... failed\n");
   }

   return;
}

static void xchgw_5(void)
{
   reg16_t arg0 = { .uw = { 1234 } };
   reg16_t arg1 = { .uw = { 5678 } };
   reg16_t result0 = arg0;
   reg16_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movw %2, %%bx\n"
         "xchgw %0, %%bx\n"
         "movw %%bx, %3\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (result1), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 5678 &&
          result1.uw[0] == 1234 )
      {
         printf("xchgw_5 ... ok\n");
      }
      else
      {
         printf("xchgw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 5678);
         printf("  result1.uw[0] = %u (expected %u)\n", result1.uw[0], 1234);
      }
   }
   else
   {
      printf("xchgw_5 ... failed\n");
   }

   return;
}

static void xchgl_1(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "xchgl %%eax, %%ebx\n"
         "movl %%eax, %2\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 12345678UL )
      {
         printf("xchgl_1 ... ok\n");
      }
      else
      {
         printf("xchgl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("xchgl_1 ... failed\n");
   }

   return;
}

static void xchgl_2(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%ebx\n"
         "movl %1, %%eax\n"
         "xchgl %%ebx, %%eax\n"
         "movl %%ebx, %2\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "ebx", "eax"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 12345678UL )
      {
         printf("xchgl_2 ... ok\n");
      }
      else
      {
         printf("xchgl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("xchgl_2 ... failed\n");
   }

   return;
}

static void xchgl_3(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %0, %%ebx\n"
         "movl %1, %%ecx\n"
         "xchgl %%ebx, %%ecx\n"
         "movl %%ebx, %2\n"
         "movl %%ecx, %3\n"
         "frstor %4\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (result1), "m" (state[0])
         : "ebx", "ecx"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 12345678UL )
      {
         printf("xchgl_3 ... ok\n");
      }
      else
      {
         printf("xchgl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("xchgl_3 ... failed\n");
   }

   return;
}

static void xchgl_4(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0;
   reg32_t result1 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %1, %%eax\n"
         "xchgl %%eax, %0\n"
         "movl %%eax, %3\n"
         "frstor %4\n"
         : "=m" (result1)
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 12345678UL )
      {
         printf("xchgl_4 ... ok\n");
      }
      else
      {
         printf("xchgl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("xchgl_4 ... failed\n");
   }

   return;
}

static void xchgl_5(void)
{
   reg32_t arg0 = { .ud = { 12345678UL } };
   reg32_t arg1 = { .ud = { 87654321UL } };
   reg32_t result0 = arg0;
   reg32_t result1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %4\n"
         "movl %2, %%ebx\n"
         "xchgl %0, %%ebx\n"
         "movl %%ebx, %3\n"
         "frstor %4\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (result1), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 87654321UL &&
          result1.ud[0] == 12345678UL )
      {
         printf("xchgl_5 ... ok\n");
      }
      else
      {
         printf("xchgl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 87654321UL);
         printf("  result1.ud[0] = %lu (expected %lu)\n", result1.ud[0], 12345678UL);
      }
   }
   else
   {
      printf("xchgl_5 ... failed\n");
   }

   return;
}

static void xorb_1(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%al\n"
         "xorb $0x34, %%al\n"
         "movb %%al, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_1 ... ok\n");
      }
      else
      {
         printf("xorb_1 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_1 ... failed\n");
   }

   return;
}

static void xorb_2(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movb %0, %%bl\n"
         "xorb $0x34, %%bl\n"
         "movb %%bl, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_2 ... ok\n");
      }
      else
      {
         printf("xorb_2 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_2 ... failed\n");
   }

   return;
}

static void xorb_3(void)
{
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "xorb $0x34, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_3 ... ok\n");
      }
      else
      {
         printf("xorb_3 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_3 ... failed\n");
   }

   return;
}

static void xorb_4(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %0, %%al\n"
         "movb %1, %%bl\n"
         "xorb %%al, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "al", "bl"
      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_4 ... ok\n");
      }
      else
      {
         printf("xorb_4 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_4 ... failed\n");
   }

   return;
}

static void xorb_5(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%al\n"
         "xorb %%al, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "al"
      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_5 ... ok\n");
      }
      else
      {
         printf("xorb_5 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_5 ... failed\n");
   }

   return;
}

static void xorb_6(void)
{
   reg8_t arg0 = { .ub = { 0x34U } };
   reg8_t arg1 = { .ub = { 0x56U } };
   reg8_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movb %1, %%bl\n"
         "xorb %0, %%bl\n"
         "movb %%bl, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bl"
      );

      if (result0.ub[0] == 0x62U )
      {
         printf("xorb_6 ... ok\n");
      }
      else
      {
         printf("xorb_6 ... not ok\n");
         printf("  result0.ub[0] = %u (expected %u)\n", result0.ub[0], 0x62U);
      }
   }
   else
   {
      printf("xorb_6 ... failed\n");
   }

   return;
}

static void xorw_1(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "xorw $0x31, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x1205 )
      {
         printf("xorw_1 ... ok\n");
      }
      else
      {
         printf("xorw_1 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x1205);
      }
   }
   else
   {
      printf("xorw_1 ... failed\n");
   }

   return;
}

static void xorw_2(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%ax\n"
         "xorw $0x4231, %%ax\n"
         "movw %%ax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_2 ... ok\n");
      }
      else
      {
         printf("xorw_2 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_2 ... failed\n");
   }

   return;
}

static void xorw_3(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movw %0, %%bx\n"
         "xorw $0x4231, %%bx\n"
         "movw %%bx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_3 ... ok\n");
      }
      else
      {
         printf("xorw_3 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_3 ... failed\n");
   }

   return;
}

static void xorw_4(void)
{
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "xorw $0x4231, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_4 ... ok\n");
      }
      else
      {
         printf("xorw_4 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_4 ... failed\n");
   }

   return;
}

static void xorw_5(void)
{
   reg16_t arg0 = { .uw = { 0x4231 } };
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %0, %%ax\n"
         "movw %1, %%bx\n"
         "xorw %%ax, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ax", "bx"
      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_5 ... ok\n");
      }
      else
      {
         printf("xorw_5 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_5 ... failed\n");
   }

   return;
}

static void xorw_6(void)
{
   reg16_t arg0 = { .uw = { 0x4231 } };
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%ax\n"
         "xorw %%ax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "ax"
      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_6 ... ok\n");
      }
      else
      {
         printf("xorw_6 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_6 ... failed\n");
   }

   return;
}

static void xorw_7(void)
{
   reg16_t arg0 = { .uw = { 0x4231 } };
   reg16_t arg1 = { .uw = { 0x1234 } };
   reg16_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movw %1, %%bx\n"
         "xorw %0, %%bx\n"
         "movw %%bx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "bx"
      );

      if (result0.uw[0] == 0x5005 )
      {
         printf("xorw_7 ... ok\n");
      }
      else
      {
         printf("xorw_7 ... not ok\n");
         printf("  result0.uw[0] = %u (expected %u)\n", result0.uw[0], 0x5005);
      }
   }
   else
   {
      printf("xorw_7 ... failed\n");
   }

   return;
}

static void xorl_1(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "xorl $0x31, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x12345649UL )
      {
         printf("xorl_1 ... ok\n");
      }
      else
      {
         printf("xorl_1 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x12345649UL);
      }
   }
   else
   {
      printf("xorl_1 ... failed\n");
   }

   return;
}

static void xorl_2(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%eax\n"
         "xorl $0x86427531, %%eax\n"
         "movl %%eax, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_2 ... ok\n");
      }
      else
      {
         printf("xorl_2 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_2 ... failed\n");
   }

   return;
}

static void xorl_3(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "movl %0, %%ebx\n"
         "xorl $0x86427531, %%ebx\n"
         "movl %%ebx, %1\n"
         "frstor %2\n"
         :
         : "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_3 ... ok\n");
      }
      else
      {
         printf("xorl_3 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_3 ... failed\n");
   }

   return;
}

static void xorl_4(void)
{
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %2\n"
         "xorl $0x86427531, %0\n"
         "frstor %2\n"
         : "=m" (result0)
         : "m" (arg1), "m" (state[0])

      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_4 ... ok\n");
      }
      else
      {
         printf("xorl_4 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_4 ... failed\n");
   }

   return;
}

static void xorl_5(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %0, %%eax\n"
         "movl %1, %%ebx\n"
         "xorl %%eax, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "eax", "ebx"
      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_5 ... ok\n");
      }
      else
      {
         printf("xorl_5 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_5 ... failed\n");
   }

   return;
}

static void xorl_6(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0 = arg1;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%eax\n"
         "xorl %%eax, %0\n"
         "frstor %3\n"
         : "=m" (result0)
         : "m" (arg0), "m" (arg1), "m" (state[0])
         : "eax"
      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_6 ... ok\n");
      }
      else
      {
         printf("xorl_6 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_6 ... failed\n");
   }

   return;
}

static void xorl_7(void)
{
   reg32_t arg0 = { .ud = { 0x86427531UL } };
   reg32_t arg1 = { .ud = { 0x12345678UL } };
   reg32_t result0;
   char state[108];

   if (sigsetjmp(catchpoint, 1) == 0)
   {
      asm(
         "fsave %3\n"
         "movl %1, %%ebx\n"
         "xorl %0, %%ebx\n"
         "movl %%ebx, %2\n"
         "frstor %3\n"
         :
         : "m" (arg0), "m" (arg1), "m" (result0), "m" (state[0])
         : "ebx"
      );

      if (result0.ud[0] == 0x94762349UL )
      {
         printf("xorl_7 ... ok\n");
      }
      else
      {
         printf("xorl_7 ... not ok\n");
         printf("  result0.ud[0] = %lu (expected %lu)\n", result0.ud[0], 0x94762349UL);
      }
   }
   else
   {
      printf("xorl_7 ... failed\n");
   }

   return;
}

int main(int argc, char **argv)
{
   signal(SIGILL, handle_sigill);

   aaa_1();
   aaa_2();
   aaa_3();
   aaa_4();
   aaa_5();
   aaa_6();
   aaa_7();
   aaa_8();
   aad_1();
   aad_2();
   aam_1();
   aam_2();
   aas_1();
   aas_2();
   aas_3();
   aas_4();
   aas_5();
   aas_6();
   aas_7();
   aas_8();
   adcb_1();
   adcb_2();
   adcb_3();
   adcb_4();
   adcb_5();
   adcb_6();
   adcb_7();
   adcb_8();
   adcb_9();
   adcb_10();
   adcb_11();
   adcb_12();
   adcw_1();
   adcw_2();
   adcw_3();
   adcw_4();
   adcw_5();
   adcw_6();
   adcw_7();
   adcw_8();
   adcw_9();
   adcw_10();
   adcw_11();
   adcw_12();
   adcw_13();
   adcw_14();
   adcl_1();
   adcl_2();
   adcl_3();
   adcl_4();
   adcl_5();
   adcl_6();
   adcl_7();
   adcl_8();
   adcl_9();
   adcl_10();
   adcl_11();
   adcl_12();
   adcl_13();
   adcl_14();
   addb_1();
   addb_2();
   addb_3();
   addb_4();
   addb_5();
   addb_6();
   addw_1();
   addw_2();
   addw_3();
   addw_4();
   addw_5();
   addw_6();
   addw_7();
   addl_1();
   addl_2();
   addl_3();
   addl_4();
   addl_5();
   addl_6();
   addl_7();
   andb_1();
   andb_2();
   andb_3();
   andb_4();
   andb_5();
   andb_6();
   andw_1();
   andw_2();
   andw_3();
   andw_4();
   andw_5();
   andw_6();
   andw_7();
   andl_1();
   andl_2();
   andl_3();
   andl_4();
   andl_5();
   andl_6();
   andl_7();
   bsfw_1();
   bsfw_2();
   bsfl_1();
   bsfl_2();
   bsrw_1();
   bsrw_2();
   bsrl_1();
   bsrl_2();
   bswapl_1();
   btw_1();
   btw_2();
   btw_3();
   btw_4();
   btw_5();
   btw_6();
   btw_7();
   btw_8();
   btl_1();
   btl_2();
   btl_3();
   btl_4();
   btl_5();
   btl_6();
   btl_7();
   btl_8();
   btcw_1();
   btcw_2();
   btcw_3();
   btcw_4();
   btcw_5();
   btcw_6();
   btcw_7();
   btcw_8();
   btcl_1();
   btcl_2();
   btcl_3();
   btcl_4();
   btcl_5();
   btcl_6();
   btcl_7();
   btcl_8();
   btrw_1();
   btrw_2();
   btrw_3();
   btrw_4();
   btrw_5();
   btrw_6();
   btrw_7();
   btrw_8();
   btrl_1();
   btrl_2();
   btrl_3();
   btrl_4();
   btrl_5();
   btrl_6();
   btrl_7();
   btrl_8();
   btsw_1();
   btsw_2();
   btsw_3();
   btsw_4();
   btsw_5();
   btsw_6();
   btsw_7();
   btsw_8();
   btsl_1();
   btsl_2();
   btsl_3();
   btsl_4();
   btsl_5();
   btsl_6();
   btsl_7();
   btsl_8();
   cbw_1();
   cbw_2();
   cdq_1();
   cdq_2();
   clc_1();
   clc_2();
   cld_1();
   cld_2();
   cmc_1();
   cmc_2();
   cmpb_1();
   cmpb_2();
   cmpb_3();
   cmpb_4();
   cmpb_5();
   cmpb_6();
   cmpb_7();
   cmpb_8();
   cmpb_9();
   cmpb_10();
   cmpb_11();
   cmpb_12();
   cmpb_13();
   cmpb_14();
   cmpb_15();
   cmpb_16();
   cmpb_17();
   cmpb_18();
   cmpb_19();
   cmpb_20();
   cmpb_21();
   cmpb_22();
   cmpb_23();
   cmpb_24();
   cmpb_25();
   cmpb_26();
   cmpb_27();
   cmpb_28();
   cmpb_29();
   cmpb_30();
   cmpb_31();
   cmpb_32();
   cmpb_33();
   cmpb_34();
   cmpb_35();
   cmpb_36();
   cmpb_37();
   cmpb_38();
   cmpb_39();
   cmpb_40();
   cmpb_41();
   cmpb_42();
   cmpb_43();
   cmpb_44();
   cmpb_45();
   cmpb_46();
   cmpb_47();
   cmpb_48();
   cmpb_49();
   cmpb_50();
   cmpb_51();
   cmpb_52();
   cmpb_53();
   cmpb_54();
   cmpb_55();
   cmpb_56();
   cmpb_57();
   cmpb_58();
   cmpb_59();
   cmpb_60();
   cmpw_1();
   cmpw_2();
   cmpw_3();
   cmpw_4();
   cmpw_5();
   cmpw_6();
   cmpw_7();
   cmpw_8();
   cmpw_9();
   cmpw_10();
   cmpw_11();
   cmpw_12();
   cmpw_13();
   cmpw_14();
   cmpw_15();
   cmpw_16();
   cmpw_17();
   cmpw_18();
   cmpw_19();
   cmpw_20();
   cmpw_21();
   cmpw_22();
   cmpw_23();
   cmpw_24();
   cmpw_25();
   cmpw_26();
   cmpw_27();
   cmpw_28();
   cmpw_29();
   cmpw_30();
   cmpw_31();
   cmpw_32();
   cmpw_33();
   cmpw_34();
   cmpw_35();
   cmpw_36();
   cmpw_37();
   cmpw_38();
   cmpw_39();
   cmpw_40();
   cmpw_41();
   cmpw_42();
   cmpw_43();
   cmpw_44();
   cmpw_45();
   cmpw_46();
   cmpw_47();
   cmpw_48();
   cmpw_49();
   cmpw_50();
   cmpw_51();
   cmpw_52();
   cmpw_53();
   cmpw_54();
   cmpw_55();
   cmpw_56();
   cmpw_57();
   cmpw_58();
   cmpw_59();
   cmpw_60();
   cmpw_61();
   cmpw_62();
   cmpw_63();
   cmpw_64();
   cmpw_65();
   cmpw_66();
   cmpw_67();
   cmpw_68();
   cmpw_69();
   cmpw_70();
   cmpw_71();
   cmpw_72();
   cmpw_73();
   cmpw_74();
   cmpw_75();
   cmpw_76();
   cmpw_77();
   cmpw_78();
   cmpw_79();
   cmpw_80();
   cmpl_1();
   cmpl_2();
   cmpl_3();
   cmpl_4();
   cmpl_5();
   cmpl_6();
   cmpl_7();
   cmpl_8();
   cmpl_9();
   cmpl_10();
   cmpl_11();
   cmpl_12();
   cmpl_13();
   cmpl_14();
   cmpl_15();
   cmpl_16();
   cmpl_17();
   cmpl_18();
   cmpl_19();
   cmpl_20();
   cmpl_21();
   cmpl_22();
   cmpl_23();
   cmpl_24();
   cmpl_25();
   cmpl_26();
   cmpl_27();
   cmpl_28();
   cmpl_29();
   cmpl_30();
   cmpl_31();
   cmpl_32();
   cmpl_33();
   cmpl_34();
   cmpl_35();
   cmpl_36();
   cmpl_37();
   cmpl_38();
   cmpl_39();
   cmpl_40();
   cmpl_41();
   cmpl_42();
   cmpl_43();
   cmpl_44();
   cmpl_45();
   cmpl_46();
   cmpl_47();
   cmpl_48();
   cmpl_49();
   cmpl_50();
   cmpl_51();
   cmpl_52();
   cmpl_53();
   cmpl_54();
   cmpl_55();
   cmpl_56();
   cmpl_57();
   cmpl_58();
   cmpl_59();
   cmpl_60();
   cmpl_61();
   cmpl_62();
   cmpl_63();
   cmpl_64();
   cmpl_65();
   cmpl_66();
   cmpl_67();
   cmpl_68();
   cmpl_69();
   cmpl_70();
   cmpl_71();
   cmpl_72();
   cmpl_73();
   cmpl_74();
   cmpl_75();
   cmpl_76();
   cmpl_77();
   cmpl_78();
   cmpl_79();
   cmpl_80();
   cmpxchgb_1();
   cmpxchgb_2();
   cmpxchgb_3();
   cmpxchgb_4();
   cmpxchgw_1();
   cmpxchgw_2();
   cmpxchgw_3();
   cmpxchgw_4();
   cmpxchgl_1();
   cmpxchgl_2();
   cmpxchgl_3();
   cmpxchgl_4();
   cwd_1();
   cwd_2();
   cwde_1();
   cwde_2();
   daa_1();
   daa_2();
   das_1();
   decb_1();
   decb_2();
   decw_1();
   decw_2();
   decl_1();
   decl_2();
   divb_1();
   divb_2();
   divw_1();
   divw_2();
   divl_1();
   divl_2();
   idivb_1();
   idivb_2();
   idivw_1();
   idivw_2();
   idivl_1();
   idivl_2();
   imulb_1();
   imulb_2();
   imulw_1();
   imulw_2();
   imull_1();
   imull_2();
   imulw_3();
   imulw_4();
   imulw_5();
   imulw_6();
   imulw_7();
   imulw_8();
   imulw_9();
   imulw_10();
   imull_3();
   imull_4();
   imull_5();
   imull_6();
   imull_7();
   imull_8();
   imull_9();
   imull_10();
   incb_1();
   incb_2();
   incw_1();
   incw_2();
   incl_1();
   incl_2();
   lahf_1();
   lahf_2();
   movb_1();
   movb_2();
   movb_3();
   movb_4();
   movb_5();
   movw_1();
   movw_2();
   movw_3();
   movw_4();
   movw_5();
   movl_1();
   movl_2();
   movl_3();
   movl_4();
   movl_5();
   movsbw_1();
   movsbw_2();
   movsbl_1();
   movsbl_2();
   movswl_1();
   movswl_2();
   movzbw_1();
   movzbw_2();
   movzbl_1();
   movzbl_2();
   movzwl_1();
   movzwl_2();
   mulb_1();
   mulb_2();
   mulw_1();
   mulw_2();
   mull_1();
   mull_2();
   negb_1();
   negb_2();
   negw_1();
   negw_2();
   negl_1();
   negl_2();
   notb_1();
   notb_2();
   notw_1();
   notw_2();
   notl_1();
   notl_2();
   orb_1();
   orb_2();
   orb_3();
   orb_4();
   orb_5();
   orb_6();
   orw_1();
   orw_2();
   orw_3();
   orw_4();
   orw_5();
   orw_6();
   orw_7();
   orl_1();
   orl_2();
   orl_3();
   orl_4();
   orl_5();
   orl_6();
   orl_7();
   rclb_1();
   rclb_2();
   rclb_3();
   rclb_4();
   rclb_5();
   rclb_6();
   rclw_1();
   rclw_2();
   rclw_3();
   rclw_4();
   rclw_5();
   rclw_6();
   rcll_1();
   rcll_2();
   rcll_3();
   rcll_4();
   rcll_5();
   rcll_6();
   rcrb_1();
   rcrb_2();
   rcrb_3();
   rcrb_4();
   rcrb_5();
   rcrb_6();
   rcrw_1();
   rcrw_2();
   rcrw_3();
   rcrw_4();
   rcrw_5();
   rcrw_6();
   rcrl_1();
   rcrl_2();
   rcrl_3();
   rcrl_4();
   rcrl_5();
   rcrl_6();
   rolb_1();
   rolb_2();
   rolb_3();
   rolb_4();
   rolb_5();
   rolb_6();
   rolw_1();
   rolw_2();
   rolw_3();
   rolw_4();
   rolw_5();
   rolw_6();
   roll_1();
   roll_2();
   roll_3();
   roll_4();
   roll_5();
   roll_6();
   rorb_1();
   rorb_2();
   rorb_3();
   rorb_4();
   rorb_5();
   rorb_6();
   rorw_1();
   rorw_2();
   rorw_3();
   rorw_4();
   rorw_5();
   rorw_6();
   rorl_1();
   rorl_2();
   rorl_3();
   rorl_4();
   rorl_5();
   rorl_6();
   sahf_1();
   sahf_2();
   salb_1();
   salb_2();
   salb_3();
   salb_4();
   salb_5();
   salb_6();
   salw_1();
   salw_2();
   salw_3();
   salw_4();
   salw_5();
   salw_6();
   sall_1();
   sall_2();
   sall_3();
   sall_4();
   sall_5();
   sall_6();
   sarb_1();
   sarb_2();
   sarb_3();
   sarb_4();
   sarb_5();
   sarb_6();
   sarw_1();
   sarw_2();
   sarw_3();
   sarw_4();
   sarw_5();
   sarw_6();
   sarl_1();
   sarl_2();
   sarl_3();
   sarl_4();
   sarl_5();
   sarl_6();
   sbbb_1();
   sbbb_2();
   sbbb_3();
   sbbb_4();
   sbbb_5();
   sbbb_6();
   sbbb_7();
   sbbb_8();
   sbbb_9();
   sbbb_10();
   sbbb_11();
   sbbb_12();
   sbbw_1();
   sbbw_2();
   sbbw_3();
   sbbw_4();
   sbbw_5();
   sbbw_6();
   sbbw_7();
   sbbw_8();
   sbbw_9();
   sbbw_10();
   sbbw_11();
   sbbw_12();
   sbbw_13();
   sbbw_14();
   sbbl_1();
   sbbl_2();
   sbbl_3();
   sbbl_4();
   sbbl_5();
   sbbl_6();
   sbbl_7();
   sbbl_8();
   sbbl_9();
   sbbl_10();
   sbbl_11();
   sbbl_12();
   sbbl_13();
   sbbl_14();
   seta_1();
   seta_2();
   seta_3();
   seta_4();
   seta_5();
   seta_6();
   seta_7();
   seta_8();
   setae_1();
   setae_2();
   setae_3();
   setae_4();
   setb_1();
   setb_2();
   setb_3();
   setb_4();
   setbe_1();
   setbe_2();
   setbe_3();
   setbe_4();
   setbe_5();
   setbe_6();
   setbe_7();
   setbe_8();
   setc_1();
   setc_2();
   setc_3();
   setc_4();
   sete_1();
   sete_2();
   sete_3();
   sete_4();
   setg_1();
   setg_2();
   setg_3();
   setg_4();
   setg_5();
   setg_6();
   setg_7();
   setg_8();
   setg_9();
   setg_10();
   setg_11();
   setg_12();
   setg_13();
   setg_14();
   setg_15();
   setg_16();
   setge_1();
   setge_2();
   setge_3();
   setge_4();
   setge_5();
   setge_6();
   setge_7();
   setge_8();
   setl_1();
   setl_2();
   setl_3();
   setl_4();
   setl_5();
   setl_6();
   setl_7();
   setl_8();
   setle_1();
   setle_2();
   setle_3();
   setle_4();
   setle_5();
   setle_6();
   setle_7();
   setle_8();
   setle_9();
   setle_10();
   setle_11();
   setle_12();
   setle_13();
   setle_14();
   setle_15();
   setle_16();
   setna_1();
   setna_2();
   setna_3();
   setna_4();
   setna_5();
   setna_6();
   setna_7();
   setna_8();
   setnae_1();
   setnae_2();
   setnae_3();
   setnae_4();
   setnb_1();
   setnb_2();
   setnb_3();
   setnb_4();
   setnbe_1();
   setnbe_2();
   setnbe_3();
   setnbe_4();
   setnbe_5();
   setnbe_6();
   setnbe_7();
   setnbe_8();
   setnc_1();
   setnc_2();
   setnc_3();
   setnc_4();
   setne_1();
   setne_2();
   setne_3();
   setne_4();
   setng_1();
   setng_2();
   setng_3();
   setng_4();
   setng_5();
   setng_6();
   setng_7();
   setng_8();
   setng_9();
   setng_10();
   setng_11();
   setng_12();
   setng_13();
   setng_14();
   setng_15();
   setng_16();
   setnge_1();
   setnge_2();
   setnge_3();
   setnge_4();
   setnge_5();
   setnge_6();
   setnge_7();
   setnge_8();
   setnl_1();
   setnl_2();
   setnl_3();
   setnl_4();
   setnl_5();
   setnl_6();
   setnl_7();
   setnl_8();
   setnle_1();
   setnle_2();
   setnle_3();
   setnle_4();
   setnle_5();
   setnle_6();
   setnle_7();
   setnle_8();
   setnle_9();
   setnle_10();
   setnle_11();
   setnle_12();
   setnle_13();
   setnle_14();
   setnle_15();
   setnle_16();
   setno_1();
   setno_2();
   setno_3();
   setno_4();
   setnp_1();
   setnp_2();
   setnp_3();
   setnp_4();
   setns_1();
   setns_2();
   setns_3();
   setns_4();
   setnz_1();
   setnz_2();
   setnz_3();
   setnz_4();
   seto_1();
   seto_2();
   seto_3();
   seto_4();
   setp_1();
   setp_2();
   setp_3();
   setp_4();
   sets_1();
   sets_2();
   sets_3();
   sets_4();
   setz_1();
   setz_2();
   setz_3();
   setz_4();
   shlb_1();
   shlb_2();
   shlb_3();
   shlb_4();
   shlb_5();
   shlb_6();
   shlw_1();
   shlw_2();
   shlw_3();
   shlw_4();
   shlw_5();
   shlw_6();
   shll_1();
   shll_2();
   shll_3();
   shll_4();
   shll_5();
   shll_6();
   shrb_1();
   shrb_2();
   shrb_3();
   shrb_4();
   shrb_5();
   shrb_6();
   shrw_1();
   shrw_2();
   shrw_3();
   shrw_4();
   shrw_5();
   shrw_6();
   shrl_1();
   shrl_2();
   shrl_3();
   shrl_4();
   shrl_5();
   shrl_6();
   shldw_1();
   shldw_2();
   shldw_3();
   shldw_4();
   shldw_5();
   shldw_6();
   shldw_7();
   shldw_8();
   shldl_1();
   shldl_2();
   shldl_3();
   shldl_4();
   shldl_5();
   shldl_6();
   shldl_7();
   shldl_8();
   shrdw_1();
   shrdw_2();
   shrdw_3();
   shrdw_4();
   shrdw_5();
   shrdw_6();
   shrdw_7();
   shrdw_8();
   shrdl_1();
   shrdl_2();
   shrdl_3();
   shrdl_4();
   shrdl_5();
   shrdl_6();
   shrdl_7();
   shrdl_8();
   stc_1();
   stc_2();
   std_1();
   std_2();
   subb_1();
   subb_2();
   subb_3();
   subb_4();
   subb_5();
   subb_6();
   subw_1();
   subw_2();
   subw_3();
   subw_4();
   subw_5();
   subw_6();
   subw_7();
   subl_1();
   subl_2();
   subl_3();
   subl_4();
   subl_5();
   subl_6();
   subl_7();
   testb_1();
   testb_2();
   testb_3();
   testb_4();
   testb_5();
   testb_6();
   testb_7();
   testb_8();
   testb_9();
   testb_10();
   testb_11();
   testb_12();
   testb_13();
   testb_14();
   testb_15();
   testb_16();
   testb_17();
   testb_18();
   testb_19();
   testb_20();
   testb_21();
   testb_22();
   testb_23();
   testb_24();
   testb_25();
   testw_1();
   testw_2();
   testw_3();
   testw_4();
   testw_5();
   testw_6();
   testw_7();
   testw_8();
   testw_9();
   testw_10();
   testw_11();
   testw_12();
   testw_13();
   testw_14();
   testw_15();
   testw_16();
   testw_17();
   testw_18();
   testw_19();
   testw_20();
   testw_21();
   testw_22();
   testw_23();
   testw_24();
   testw_25();
   testl_1();
   testl_2();
   testl_3();
   testl_4();
   testl_5();
   testl_6();
   testl_7();
   testl_8();
   testl_9();
   testl_10();
   testl_11();
   testl_12();
   testl_13();
   testl_14();
   testl_15();
   testl_16();
   testl_17();
   testl_18();
   testl_19();
   testl_20();
   testl_21();
   testl_22();
   testl_23();
   testl_24();
   testl_25();
   xaddb_1();
   xaddb_2();
   xaddw_1();
   xaddw_2();
   xaddl_1();
   xaddl_2();
   xchgb_1();
   xchgb_2();
   xchgb_3();
   xchgw_1();
   xchgw_2();
   xchgw_3();
   xchgw_4();
   xchgw_5();
   xchgl_1();
   xchgl_2();
   xchgl_3();
   xchgl_4();
   xchgl_5();
   xorb_1();
   xorb_2();
   xorb_3();
   xorb_4();
   xorb_5();
   xorb_6();
   xorw_1();
   xorw_2();
   xorw_3();
   xorw_4();
   xorw_5();
   xorw_6();
   xorw_7();
   xorl_1();
   xorl_2();
   xorl_3();
   xorl_4();
   xorl_5();
   xorl_6();
   xorl_7();

   exit(0);
}