gcc/testsuite/gcc.target/powerpc/int_128bit-runnable.c

/* { dg-do run } */
/* { dg-options "-mdejagnu-cpu=power10 -save-temps" } */
/* { dg-require-effective-target power10_hw } */

/* Check that the expected 128-bit instructions are generated if the processor
   supports the 128-bit integer instructions. */
/* { dg-final { scan-assembler-times {\mvextsd2q\M} 6 } } */
/* { dg-final { scan-assembler-times {\mvslq\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvsrq\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvsraq\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvrlq\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvrlqnm\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvrlqmi\M} 2 } } */
/* { dg-final { scan-assembler-times {\mvcmpequq\M} 24 } } */
/* { dg-final { scan-assembler-times {\mvcmpgtsq\M} 26 } } */
/* { dg-final { scan-assembler-times {\mvcmpgtuq\M} 26 } } */
/* { dg-final { scan-assembler-times {\mvmuloud\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvmulesd\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvmulosd\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvmulld\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvdivsq\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvdivuq\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvdivesq\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvdiveuq\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvmodsq\M} 1 } } */
/* { dg-final { scan-assembler-times {\mvmoduq\M} 1 } } */

#include <altivec.h>

#define DEBUG 0

#if DEBUG
#include <stdio.h>
#include <stdlib.h>
#include <math.h>


void print_i128(__int128_t val)
{
  printf(" %lld %llu (0x%llx %llx)",
	 (signed long long)(val >> 64),
	 (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF),
	 (unsigned long long)(val >> 64),
	 (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF));
}
#endif

void abort (void);

__attribute__((noinline))
__int128_t shift_right (__int128_t a, __uint128_t b)
{
  return a >> b;
}

__attribute__((noinline))
__int128_t shift_left (__int128_t a, __uint128_t b)
{
  return a << b;
}

int main ()
{
  int i, result_int;

  __int128_t arg1, result;
  __uint128_t uarg2;

  _Decimal128 arg1_dfp128, result_dfp128, expected_result_dfp128;

  struct conv_t {
    __uint128_t u128;
    _Decimal128 d128;
  } conv, conv2;

  vector signed long long int vec_arg1_di, vec_arg2_di;
  vector signed long long int vec_result_di, vec_expected_result_di;
  vector unsigned long long int vec_uarg1_di, vec_uarg2_di, vec_uarg3_di;
  vector unsigned long long int vec_uresult_di;
  vector unsigned long long int vec_uexpected_result_di;
  
  __int128_t expected_result;
  __uint128_t uexpected_result;

  vector __int128 vec_arg1, vec_arg2, vec_result;
  vector unsigned __int128 vec_uarg1, vec_uarg2, vec_uarg3, vec_uresult;
  vector bool __int128  vec_result_bool;

  /* sign extend double to 128-bit integer  */
  vec_arg1_di[0] = 1000;
  vec_arg1_di[1] = -123456;

  expected_result = 1000;

  vec_result = vec_signextq (vec_arg1_di);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_signextq ((long long) %lld) =  ",  vec_arg1_di[0]);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1_di[0] = -123456;
  vec_arg1_di[1] = 1000;

  expected_result = -123456;

  vec_result = vec_signextq (vec_arg1_di);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_signextq ((long long) %lld) =  ",  vec_arg1_di[0]);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
  
  /* test shift 128-bit integers.
     Note, shift amount is given by the lower 7-bits of the shift amount. */
  vec_arg1[0] = 3;
  vec_uarg2[0] = 2;
  expected_result = vec_arg1[0]*4;

  vec_result = vec_sl (vec_arg1, vec_uarg2);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_sl(int128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" << %lld", vec_uarg2[0] & 0xFF);
    printf(" = ");
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  arg1 = vec_result[0];
  uarg2 = 4;
  expected_result = arg1*16;

  result = arg1 << uarg2;

  if (result != expected_result) {
#if DEBUG
    printf("ERROR: int128 << uint128):  ");
    print_i128(arg1);
    printf(" << %lld", uarg2 & 0xFF);
    printf(" = ");
    print_i128(result);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 3;
  vec_uarg2[0] = 2;
  uexpected_result = vec_uarg1[0]*4;
  
  vec_uresult = vec_sl (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_sl(uint128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" << %lld", vec_uarg2[0] & 0xFF);
    printf(" = ");
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12;
  vec_uarg2[0] = 2;
  expected_result = vec_arg1[0]/4;

  vec_result = vec_sr (vec_arg1, vec_uarg2);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_sr(int128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" >> %lld", vec_uarg2[0] & 0xFF);
    printf(" = ");
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 48;
  vec_uarg2[0] = 2;
  uexpected_result = vec_uarg1[0]/4;
  
  vec_uresult = vec_sr (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_sr(uint128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" >> %lld", vec_uarg2[0] & 0xFF);
    printf(" = ");
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  arg1 = vec_uresult[0];
  uarg2 = 4;
  expected_result = arg1/16;

  result = arg1 >> uarg2;

  if (result != expected_result) {
#if DEBUG
    printf("ERROR: int128 >> uint128:  ");
    print_i128(arg1);
    printf(" >> %lld", uarg2 & 0xFF);
    printf(" = ");
    print_i128(result);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 0x1234567890ABCDEFULL;
  vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
  vec_uarg2[0] = 32;
  expected_result = 0x0000000012345678ULL;
  expected_result = (expected_result << 64) | 0x90ABCDEFAABBCCDDULL;

  vec_result = vec_sra (vec_arg1, vec_uarg2);
  
  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_sra(int128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" >> %lld = \n", vec_uarg2[0]);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
  vec_uarg2[0] = 48;
  uexpected_result = 0xFFFFFFFFFFFFAABBLL;
  uexpected_result = (uexpected_result << 64) | 0xCCDDEEFF11221234ULL;

  vec_uresult = vec_sra (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_sra(uint128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" >> %lld = \n", vec_uarg2[0] & 0xFF);
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 0x1234567890ABCDEFULL;
  vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
  vec_uarg2[0] = 32;
  expected_result = 0x90ABCDEFAABBCCDDULL;
  expected_result = (expected_result << 64) | 0xEEFF112212345678ULL;

  vec_result = vec_rl (vec_arg1, vec_uarg2);
  
  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_rl(int128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" >> %lld = \n", vec_uarg2[0]);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
  vec_uarg2[0] = 48;
  uexpected_result = 0x11221234567890ABULL;
  uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDEEFFULL;

  vec_uresult = vec_rl (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_rl(uint128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" >> %lld = \n", vec_uarg2[0]);
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* vec_rlnm(arg1, arg2, arg3)
     result - rotate each element of arg1 left by shift in element of arg2.
       Then AND with mask whose  start/stop bits are specified in element of
       arg3.  */
  vec_arg1[0] = 0x1234567890ABCDEFULL;
  vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
  vec_uarg2[0] = 32;
  vec_uarg3[0] = (32 << 8) | 95;
  expected_result = 0xaabbccddULL;
  expected_result = (expected_result << 64) | 0xeeff112200000000ULL;

  vec_result = vec_rlnm (vec_arg1, vec_uarg2, vec_uarg3);
  
  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_rlnm(int128, uint128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" << %lld = \n", vec_uarg3[0] & 0xFF);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  

  /* vec_rlnm(arg1, arg2, arg3)
     result - rotate each element of arg1 left by shift in element of arg2;
     then AND with mask whose  start/stop bits are specified in element of
     arg3.  */
  vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
  vec_uarg2[0] = 48;
  vec_uarg3[0] = (8 << 8) | 119;

  uexpected_result = 0x00221234567890ABULL;
  uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDEE00ULL;

  vec_uresult = vec_rlnm (vec_uarg1, vec_uarg2, vec_uarg3);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_rlnm(uint128, uint128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" << %lld = \n", vec_uarg3[0] & 0xFF);
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /*  vec_rlmi(R, A, B)
      Result value: Each element of R is obtained by rotating the corresponding
      element of A left by the number of bits specified by the corresponding element
      of B.  */

  vec_arg1[0] = 0x1234567890ABCDEFULL;
  vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
  vec_arg2[0] = 0x000000000000DEADULL;
  vec_arg2[0] = (vec_arg2[0] << 64) | 0x0000BEEF00000000ULL;
  vec_uarg3[0] = 96 << 16 | 127 << 8 | 32;
  expected_result = 0x000000000000DEADULL;
  expected_result = (expected_result << 64) | 0x0000BEEF12345678ULL;

  vec_result = vec_rlmi (vec_arg1, vec_arg2, vec_uarg3);
  
  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_rlmi(int128, int128, uint128):  ");
    print_i128(vec_arg1[0]);
    printf(" << %lld = \n", vec_uarg2_di[1] & 0xFF);
    print_i128(vec_result[0]);
    printf("\n does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* vec_rlmi(R, A, B)
     Result value: Each element of R is obtained by rotating the corresponding
     element of A left by the number of bits specified by the corresponding element
     of B.  */

  vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
  vec_uarg2[0] = 0xDEAD000000000000ULL;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 0x000000000000BEEFULL;
  vec_uarg3[0] = 16 << 16 | 111 << 8 | 48;
  uexpected_result = 0xDEAD1234567890ABULL;
  uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDBEEFULL;

  vec_uresult = vec_rlmi (vec_uarg1, vec_uarg2, vec_uarg3);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_rlmi(uint128, unit128, uint128):  ");
    print_i128(vec_uarg1[0]);
    printf(" << %lld = \n", vec_uarg3[1] & 0xFF);
    print_i128(vec_uresult[0]);
    printf("\n does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* 128-bit compare tests, result is all 1's if true */
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1[0] = 2468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  uexpected_result = 0xFFFFFFFFFFFFFFFFULL;
  uexpected_result = (uexpected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpgt (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: unsigned vec_cmpgt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpgt (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed vec_cmpgt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }


  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = -1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmpeq (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR:not equal signed vec_cmpeq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpeq (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed equal vec_cmpeq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 12468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmpeq (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  not equal vec_cmpeq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpeq (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: equal unsigned vec_cmpeq ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 12468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpne (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  not equal vec_cmpne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmpne (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: equal unsigned vec_cmpne ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = -1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpne (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR:not equal signed vec_cmpne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmpne (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed equal vec_cmpne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 12468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 > arg2 vec_cmplt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 1234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 12468;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 < arg2 vec_cmplt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR:  unsigned arg1 = arg2 vec_cmplt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = -1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 > arg2 vec_cmplt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = -1234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 12468;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 < arg2 vec_cmplt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;
  expected_result = 0x0ULL;

  vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_cmplt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
   
  vec_uarg1[0] = 12468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 > arg2 vec_cmple ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 1234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 12468;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 < arg2 vec_cmple ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR:  unsigned arg1 = arg2 vec_cmple ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = -1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmple (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 > arg2 vec_cmple ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = -1234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 12468;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmple (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 < arg2 vec_cmple ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmple (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_cmple ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 12468;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 > arg2 vec_cmpge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 1234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 12468;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: unsigned  arg1 < arg2 vec_cmpge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR:  unsigned arg1 = arg2 vec_cmpge ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = 12468;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = -1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 > arg2 vec_cmpge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg1[0] = -1234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 12468;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  expected_result = 0x0;

  vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed  arg1 < arg2 vec_cmpge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;
  expected_result = 0xFFFFFFFFFFFFFFFFULL;
  expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;

  vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);

  if (vec_result_bool[0] != expected_result) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_cmpge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.");
    print_i128(vec_result_bool[0]);
    printf("\n Result does not match expected_result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

#if 1
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_eq (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_eq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_eq (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_eq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_eq (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_eq ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_eq (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_eq ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_ne (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_ne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_ne (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_ne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_ne (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_ne ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_ne (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_ne ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_lt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_lt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_lt (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_lt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_lt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_lt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_lt (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_lt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_le (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_le ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_le (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_le ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_le (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_le ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_le (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_le ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_gt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_gt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_gt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_gt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_gt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_gt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_gt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_gt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_all_ge (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_all_ge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_all_ge (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_all_ge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_all_ge (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_all_ge ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_all_ge (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_all_ge ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_eq (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_eq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_eq (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_eq ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_eq (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_eq ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_eq (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_eq ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_ne (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_ne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_ne (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_ne ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_ne (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_ne ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_ne (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_ne ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_lt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_lt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_lt (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_lt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_lt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_lt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_lt (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_lt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_gt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_gt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_gt (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_gt ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_gt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_gt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_gt (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_gt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_le (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_le ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_le (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_le ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_le (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_le ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_le (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_le ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }

  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
  vec_arg1 = vec_arg2;

  result_int = vec_any_ge (vec_arg1, vec_arg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: signed arg1 = arg2 vec_any_ge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1[0] = -234;
  vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
  vec_arg2[0] = 1234;
  vec_arg2[0] = (vec_arg2[0] << 64) | 4567;

  result_int = vec_any_ge (vec_arg1, vec_arg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: signed arg1 != arg2 vec_any_ge ( ");
    print_i128(vec_arg1[0]);
    printf(", ");
    print_i128(vec_arg2[0]);
    printf(") failed.\n\n");
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
  vec_uarg1 = vec_uarg2;

  result_int = vec_any_ge (vec_uarg1, vec_uarg2);

  if (!result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 = uarg2 vec_any_ge ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1[0] = 234;
  vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
  vec_uarg2[0] = 1234;
  vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;

  result_int = vec_any_ge (vec_uarg1, vec_uarg2);

  if (result_int) {
#if DEBUG
    printf("ERROR: unsigned uarg1 != uarg2 vec_any_gt ( ");
    print_i128(vec_uarg1[0]);
    printf(", ");
    print_i128(vec_uarg2[0]);
    printf(") failed.\n\n");
#else
    abort();
#endif
  }
#endif

  /* Vector multiply Even and Odd tests */
  vec_arg1_di[0] = 200;
  vec_arg1_di[1] = 400;
  vec_arg2_di[0] = 1234;
  vec_arg2_di[1] = 4567;
  expected_result = vec_arg1_di[0] * vec_arg2_di[0];

  vec_result = vec_mule (vec_arg1_di, vec_arg2_di);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_mule (signed, signed) failed.\n");
    printf(" vec_arg1_di[0] = %lld\n", vec_arg1_di[0]);
    printf(" vec_arg2_di[0] = %lld\n", vec_arg2_di[0]);
    printf("Result = ");
    print_i128(vec_result[0]);
    printf("\nExpected Result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_arg1_di[0] = -200;
  vec_arg1_di[1] = -400;
  vec_arg2_di[0] = 1234;
  vec_arg2_di[1] = 4567;
  expected_result = vec_arg1_di[1] * vec_arg2_di[1];

  vec_result = vec_mulo (vec_arg1_di, vec_arg2_di);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_mulo (signed, signed) failed.\n");
    printf(" vec_arg1_di[1] = %lld\n", vec_arg1_di[1]);
    printf(" vec_arg2_di[1] = %lld\n", vec_arg2_di[1]);
    printf("Result = ");
    print_i128(vec_result[0]);
    printf("\nExpected Result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1_di[0] = 200;
  vec_uarg1_di[1] = 400;
  vec_uarg2_di[0] = 1234;
  vec_uarg2_di[1] = 4567;
  uexpected_result = vec_uarg1_di[0] * vec_uarg2_di[0];

  vec_uresult = vec_mule (vec_uarg1_di, vec_uarg2_di);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_mule (unsigned, unsigned) failed.\n");
    printf(" vec_uarg1_di[1] = %lld\n", vec_uarg1_di[1]);
    printf(" vec_uarg2_di[1] = %lld\n", vec_uarg2_di[1]);
    printf("Result = ");
    print_i128(vec_uresult[0]);
    printf("\nExpected Result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
  
  vec_uarg1_di[0] = 200;
  vec_uarg1_di[1] = 400;
  vec_uarg2_di[0] = 1234;
  vec_uarg2_di[1] = 4567;
  uexpected_result = vec_uarg1_di[1] * vec_uarg2_di[1];

  vec_uresult = vec_mulo (vec_uarg1_di, vec_uarg2_di);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_mulo (unsigned, unsigned) failed.\n");
    printf(" vec_uarg1_di[0] = %lld\n", vec_uarg1_di[0]);
    printf(" vec_uarg2_di[0] = %lld\n", vec_uarg2_di[0]);
    printf("Result = ");
    print_i128(vec_uresult[0]);
    printf("\nExpected Result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* Vector Multiply Longword */
  vec_arg1_di[0] = 100;
  vec_arg1_di[1] = -123456;

  vec_arg2_di[0] = 123;
  vec_arg2_di[1] = 1000;

  vec_expected_result_di[0] = 12300;
  vec_expected_result_di[1] = -123456000;

  vec_result_di = vec_arg1_di * vec_arg2_di;

  for (i = 0; i<2; i++) {
    if (vec_result_di[i] != vec_expected_result_di[i]) {
#if DEBUG
      printf("ERROR: vector multipy [%d] ((long long) %lld) =  ", i,
	     vec_result_di[i]);
      printf("\n does not match expected_result [%d] = ((long long) %lld)", i,
	     vec_expected_result_di[i]);
      printf("\n\n");
#else
      abort();
#endif
    }
  }

  /* Vector Divide Quadword */
  vec_arg1[0] = -12345678;
  vec_arg2[0] = 2;
  expected_result = -6172839;

  vec_result = vec_div (vec_arg1, vec_arg2);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_div (signed, signed) failed.\n");
    printf("vec_arg1[0] = ");
    print_i128(vec_arg1[0]);
    printf("\nvec_arg2[0] = ");
    print_i128(vec_arg2[0]);
    printf("\nResult = ");
    print_i128(vec_result[0]);
    printf("\nExpected result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 24680;
  vec_uarg2[0] = 4;
  uexpected_result = 6170;

  vec_uresult = vec_div (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_div (unsigned, unsigned) failed.\n");
    printf("vec_uarg1[0] = ");
    print_i128(vec_uarg1[0]);
    printf("\nvec_uarg2[0] = ");
    print_i128(vec_uarg2[0]);
    printf("\nResult = ");
    print_i128(vec_uresult[0]);
    printf("\nExpected result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* Vector Divide Extended Quadword */
  vec_arg1[0] = -20;        // has 128-bit of zero concatenated onto it
  vec_arg2[0] = 0x2000000000000000;
  vec_arg2[0] = vec_arg2[0] << 64;
  expected_result = -160;

  vec_result = vec_dive (vec_arg1, vec_arg2);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_dive (signed, signed) failed.\n");
    printf("vec_arg1[0] = ");
    print_i128(vec_arg1[0]);
    printf("\nvec_arg2[0] = ");
    print_i128(vec_arg2[0]);
    printf("\nResult = ");
    print_i128(vec_result[0]);
    printf("\nExpected result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 20;        // has 128-bit of zero concatenated onto it
  vec_uarg2[0] = 0x4000000000000000;
  vec_uarg2[0] = vec_uarg2[0] << 64;
  uexpected_result = 80;

  vec_uresult = vec_dive (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_dive (unsigned, unsigned) failed.\n");
    printf("vec_uarg1[0] = ");
    print_i128(vec_uarg1[0]);
    printf("\nvec_uarg2[0] = ");
    print_i128(vec_uarg2[0]);
    printf("\nResult = ");
    print_i128(vec_uresult[0]);
    printf("\nExpected result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  /* Vector modulo quad word  */
  vec_arg1[0] = -12345675;
  vec_arg2[0] = 2;
  expected_result = -1;

  vec_result = vec_mod (vec_arg1, vec_arg2);

  if (vec_result[0] != expected_result) {
#if DEBUG
    printf("ERROR: vec_mod (signed, signed) failed.\n");
    printf("vec_arg1[0] = ");
    print_i128(vec_arg1[0]);
    printf("\nvec_arg2[0] = ");
    print_i128(vec_arg2[0]);
    printf("\nResult = ");
    print_i128(vec_result[0]);
    printf("\nExpected result = ");
    print_i128(expected_result);
    printf("\n\n");
#else
    abort();
#endif
  }

  vec_uarg1[0] = 24685;
  vec_uarg2[0] = 4;
  uexpected_result = 1;

  vec_uresult = vec_mod (vec_uarg1, vec_uarg2);

  if (vec_uresult[0] != uexpected_result) {
#if DEBUG
    printf("ERROR: vec_mod (unsigned, unsigned) failed.\n");
    printf("vec_uarg1[0] = ");
    print_i128(vec_uarg1[0]);
    printf("\nvec_uarg2[0] = ");
    print_i128(vec_uarg2[0]);
    printf("\nResult = ");
    print_i128(vec_uresult[0]);
    printf("\nExpected result = ");
    print_i128(uexpected_result);
    printf("\n\n");
#else
    abort();
#endif
  }
  
  /* DFP to __int128 and __int128 to DFP conversions */
  /* Print the DFP value as an unsigned int so we can see the bit patterns.  */
  conv.u128 = 0x2208000000000000ULL;
  conv.u128 = (conv.u128 << 64) | 0x4ULL;   //DFP bit pattern for integer 4
  expected_result_dfp128 = conv.d128;

  arg1 = 4;

  conv.d128 = (_Decimal128) arg1;

  result_dfp128 = (_Decimal128) arg1;
  if (((conv.u128 >>64) != 0x2208000000000000ULL) &&
      ((conv.u128 & 0xFFFFFFFFFFFFFFFF) != 0x4ULL)) {
#if DEBUG
    printf("ERROR:  convert int128 value ");
    print_i128 (arg1);
    conv.d128 = result_dfp128;
    printf("\nto DFP value 0x%llx %llx (printed as hex bit string) ",
	   (unsigned long long)((conv.u128) >>64),
	   (unsigned long long)((conv.u128) & 0xFFFFFFFFFFFFFFFF));

    conv.d128 = expected_result_dfp128;
    printf("\ndoes not match expected_result = 0x%llx %llx\n\n",
	   (unsigned long long) (conv.u128>>64),
	   (unsigned long long) (conv.u128 & 0xFFFFFFFFFFFFFFFF));
#else
    abort();
#endif
  }

  expected_result = 4;

  conv.u128 = 0x2208000000000000ULL;
  conv.u128 = (conv.u128 << 64) | 0x4ULL;  // 4 as DFP
  arg1_dfp128 = conv.d128;

  result = (__int128_t) arg1_dfp128;

  if (result != expected_result) {
#if DEBUG
    printf("ERROR:  convert DFP value ");
    printf("0x%llx %llx (printed as hex bit string) ",
	   (unsigned long long)(conv.u128>>64),
	   (unsigned long long)(conv.u128 & 0xFFFFFFFFFFFFFFFF));
    printf("to __int128 value = ");
    print_i128 (result);
    printf("\ndoes not match expected_result = ");
    print_i128 (expected_result);
    printf("\n");
#else
    abort();
#endif
  }
  return 0;
}