/* { dg-do run } */
/* { dg-require-effective-target p9vector_hw } */
/* { dg-require-effective-target int128 } */
/* { dg-options "-mdejagnu-cpu=power9 -O2" } */

#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
#include <altivec.h> // vector

#define TRUE 1
#define FALSE 0

#ifdef DEBUG
#include <stdio.h>
#endif

void abort (void);

int result_wrong_sc (vector signed char vec_expected,
		     vector signed char vec_actual)
{
  int i;

  for (i = 0; i < 16; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_uc (vector unsigned char vec_expected,
		     vector unsigned char vec_actual)
{
  int i;

  for (i = 0; i < 16; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_us (vector unsigned short vec_expected,
		     vector unsigned short vec_actual)
{
  int i;

  for (i = 0; i < 8; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_ss (vector signed short vec_expected,
		     vector signed short vec_actual)
{
  int i;

  for (i = 0; i < 8; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_ui (vector unsigned int vec_expected,
		     vector unsigned int vec_actual)
{
  int i;

  for (i = 0; i < 4; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_ull (vector unsigned long long vec_expected,
		      vector unsigned long long vec_actual)
{
  int i;

  for (i = 0; i < 2; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_sll (vector signed long long vec_expected,
		      vector signed long long vec_actual)
{
  int i;

  for (i = 0; i < 2; i++)
    {
      if (vec_expected[i] != vec_actual[i])
        return TRUE;
    }

  return FALSE;
}

int result_wrong_si (vector signed int vec_expected,
		     vector signed int vec_actual)
{
  int i;

  for (i = 0; i < 4; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_u128 (vector __uint128_t vec_expected,
		       vector __uint128_t vec_actual)
{
  int i;

  if (vec_expected[0] != vec_actual[0])
    return TRUE;

  return FALSE;
}

int result_wrong_s128 (vector __int128_t vec_expected,
		       vector __int128_t vec_actual)
{
  int i;

  if (vec_expected[0] != vec_actual[0])
    return TRUE;

  return FALSE;
}

int result_wrong_d (vector double vec_expected,
		    vector double vec_actual)
{
  int i;

  for (i = 0; i < 2; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

int result_wrong_f (vector float vec_expected,
		    vector float vec_actual)
{
  int i;

  for (i = 0; i < 4; i++)
    if (vec_expected[i] != vec_actual[i])
      return TRUE;

  return FALSE;
}

#ifdef DEBUG
void print_sc (vector signed char vec_expected,
	       vector signed char vec_actual)
{
  int i;

  printf("expected signed char data\n");
  for (i = 0; i < 16; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual signed char data\n");
  for (i = 0; i < 16; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_uc (vector unsigned char vec_expected,
	       vector unsigned char vec_actual)
{
  int i;

  printf("expected signed char data\n");
  for (i = 0; i < 16; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual signed char data\n");
  for (i = 0; i < 16; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_us (vector unsigned short vec_expected,
	       vector unsigned short vec_actual)
{
  int i;

  printf("expected unsigned short data\n");
  for (i = 0; i < 8; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual unsigned short data\n");
  for (i = 0; i < 8; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_ss (vector signed short vec_expected,
	       vector signed short vec_actual)
{
  int i;

  printf("expected signed short data\n");
  for (i = 0; i < 8; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual signed short data\n");
  for (i = 0; i < 8; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_ui (vector unsigned int vec_expected,
	       vector unsigned int vec_actual)
{
  int i;

  printf("expected unsigned int data\n");
  for (i = 0; i < 4; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual unsigned int data\n");
  for (i = 0; i < 4; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_si (vector signed int vec_expected,
	       vector signed int vec_actual)
{
  int i;

  printf("expected signed int data\n");
  for (i = 0; i < 4; i++)
    printf(" %d,", vec_expected[i]);

  printf("\nactual signed int data\n");
  for (i = 0; i < 4; i++)
    printf(" %d,", vec_actual[i]);
  printf("\n");
}

void print_ull (vector unsigned long long vec_expected,
		vector unsigned long long vec_actual)
{
  int i;

  printf("expected unsigned long long data\n");
  for (i = 0; i < 2; i++)
    printf(" %llu,", vec_expected[i]);

  printf("\nactual unsigned long long data\n");
  for (i = 0; i < 2; i++)
    printf(" %llu,", vec_actual[i]);
  printf("\n");
}

void print_sll (vector signed long long vec_expected,
		vector signed long long vec_actual)
{
  int i;

  printf("expected signed long long data\n");
  for (i = 0; i < 2; i++)
    printf(" %lld,", vec_expected[i]);

  printf("\nactual signed long long data\n");
  for (i = 0; i < 2; i++)
    printf(" %lld,", vec_actual[i]);
  printf("\n");
}

void print_u128 (vector __uint128_t vec_expected,
		 vector __uint128_t vec_actual)
{
  printf("expected uint128 data\n");
  printf(" %llu%llu\n", (unsigned long long)(vec_expected[0] >> 64),
	 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));

  printf("\nactual uint128 data\n");
  printf(" %llu%llu\n", (unsigned long long)(vec_actual[0] >> 64),
	 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
}

void print_s128 (vector __int128 vec_expected,
		 vector __int128 vec_actual)
{
  printf("expected int128 data\n");
  printf(" %lld%llu\n", (signed long long)(vec_expected[0] >> 64),
	 (unsigned long long)(vec_expected[0] & 0xFFFFFFFFFFFFFFFF));

  printf("\nactual int128 data\n");
  printf(" %lld%llu\n", (signed long long)(vec_actual[0] >> 64),
	 (unsigned long long)(vec_actual[0] & 0xFFFFFFFFFFFFFFFF));
}

void print_d (vector double vec_expected,
	      vector double vec_actual)
{
  int i;

  printf("expected double data\n");
  for (i = 0; i < 2; i++)
    printf(" %f,", vec_expected[i]);

  printf("\nactual double data\n");
  for (i = 0; i < 2; i++)
    printf(" %f,", vec_actual[i]);
  printf("\n");
}

void print_f (vector float vec_expected,
	      vector float vec_actual)
{
  int i;

  printf("expected float data\n");
  for (i = 0; i < 4; i++)
    printf(" %f,", vec_expected[i]);

  printf("\nactual float data\n");
  for (i = 0; i < 4; i++)
    printf(" %f,", vec_actual[i]);
  printf("\n");
}
#endif

typedef union
{
  vector __int128_t i1;
  __int128_t i2;
  vector __uint128_t u1;
  __uint128_t u2;
  struct
  {
    long long d1;
    long long d2;
  };
} U128;

/* For a given long long VALUE, ensure it's stored from the beginning
   of {u,}int128 memory storage (the low address), it avoids to load
   unexpected data without the whole vector length.  */

static inline void
getU128 (U128 *pu, unsigned long long value)
{
  pu->d1 = value;
  pu->d2 = 0;
}

int main() {
  int i, j;
  size_t len;
  signed char data_c[100];
  vector signed char input_c;
  unsigned char data_uc[100];
  vector unsigned char input_uc;

  signed short int data_ssi[100];
  vector signed short int input_ssi;
  unsigned short int data_usi[100];
  vector unsigned short int input_usi;

  signed int data_si[100];
  vector signed int input_si;
  unsigned int data_ui[100];
  vector unsigned int input_ui;

  signed long long data_sll[100];
  vector signed long long  input_sll;
  unsigned long long data_ull[100];
  vector unsigned long long int input_ull;

  float data_f[100];
  vector float input_f;
  double data_d[100];
  vector double input_d;
  __uint128_t data_u128[100];
  vector __uint128_t input_u128;
  __int128_t data_128[100];
  vector __int128_t input_128;

  vector signed char store_data_sc;
  vector unsigned char store_data_uc;
  vector signed int store_data_si;
  vector unsigned int store_data_ui;
  vector __int128_t store_data_s128;
  vector __uint128_t store_data_u128;
  vector signed long long int store_data_sll;
  vector unsigned long long int store_data_ull;
  vector signed short store_data_ss;
  vector unsigned short store_data_us;
  vector double store_data_d;
  vector float store_data_f;

  signed char *address_sc;
  unsigned char *address_uc;
  signed int *address_si;
  unsigned int *address_ui;
  __int128_t *address_s128;
  __uint128_t *address_u128;
  signed long long int *address_sll;
  unsigned long long int *address_ull;
  signed short int *address_ss;
  unsigned short int *address_us;
  double *address_d;
  float *address_f;

  vector unsigned char *datap;

  vector unsigned char vec_uc_expected1, vec_uc_result1;
  vector signed char vec_sc_expected1, vec_sc_result1;
  vector signed int vec_si_expected1, vec_si_result1;
  vector unsigned int vec_ui_expected1, vec_ui_result1;
  vector __int128_t vec_s128_expected1, vec_s128_result1;
  vector __uint128_t vec_u128_expected1, vec_u128_result1;
  vector signed long long int vec_sll_expected1, vec_sll_result1;
  vector unsigned long long int vec_ull_expected1, vec_ull_result1;
  vector signed short int vec_ss_expected1, vec_ss_result1;
  vector unsigned short int vec_us_expected1, vec_us_result1;
  vector double vec_d_expected1, vec_d_result1;
  vector float vec_f_expected1, vec_f_result1;

  signed long long disp;

  /* VEC_XST_LEN, ISA 3.0 */
  len = 16;
  vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
					   1, 2, 3, 4, 5, 6, 7, 8 };
  store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
					1, 2, 3, 4, 5, 6, 7, 8 };
  vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0 };

  address_sc = &vec_sc_result1[0];

  vec_xst_len (store_data_sc, address_sc, len);

  if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n", len);
       print_sc (vec_sc_expected1, vec_sc_result1);
#else
       abort();
#endif
    }

  len = 12;
  vec_sc_expected1 = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
					   1, 2, 3, 4, 0, 0, 0, 0 };
  store_data_sc = (vector signed char){ -7, -6, -5, -4, -3, -2, -1, 0,
					1, 2, 3, 4, 5, 6, 7, 8 };
  vec_sc_result1 = (vector signed char){ 0, 0, 0, 0, 0, 0, 0, 0,
                                         0, 0, 0, 0, 0, 0, 0, 0 };

  address_sc = &vec_sc_result1[0];

  vec_xst_len (store_data_sc, address_sc, len);

  if (result_wrong_sc (vec_sc_expected1, vec_sc_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, sc result does not match expected result\n",
	      len);
       print_sc (vec_sc_expected1, vec_sc_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
					     8, 9, 10, 11, 12, 13, 14, 15 };

  store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
					  8, 9, 10, 11, 12, 13, 14, 15 };

  vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
					   0, 0, 0, 0, 0, 0, 0, 0 };

  address_uc = &vec_uc_result1[0];

  vec_xst_len (store_data_uc, address_uc, len);

  if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
    {
#ifdef DEBUG
      printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
	     len);
      print_uc (vec_uc_expected1, vec_uc_result1);
#else
      abort();
#endif
    }

  len = 4;
  vec_uc_expected1 = (vector unsigned char){ 0, 1, 2, 3, 0, 0, 0, 0,
					     0, 0, 0, 0, 0, 0, 0, 0 };
  store_data_uc = (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7,
					  8, 9, 10, 11, 12, 13, 14, 15 };
  vec_uc_result1 = (vector unsigned char){ 0, 0, 0, 0, 0, 0, 0, 0,
					   0, 0, 0, 0, 0, 0, 0, 0 };

  address_uc = &vec_uc_result1[0];

  vec_xst_len (store_data_uc, address_uc, len);

  if (result_wrong_uc (vec_uc_expected1, vec_uc_result1))
    {
#ifdef DEBUG
      printf("Error: vec_xst_len, len = %d, uc result does not match expected result\n",
	      len);
      print_uc (vec_uc_expected1, vec_uc_result1);
#else
      abort();
#endif
    }

  len = 16;
  vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
						50, 60, 70, 80 };
  store_data_ss = (vector signed short int){ 10, 20, 30, 40,
					     50, 60, 70, 80 };
  vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};

  address_ss = &vec_ss_result1[0];

  vec_xst_len (store_data_ss, address_ss, len);

  if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
	      len);
       print_ss (vec_ss_expected1, vec_ss_result1);
#else
       abort();
#endif
    }

  len = 14;
  vec_ss_expected1 = (vector signed short int){ 10, 20, 30, 40,
						50, 60, 70, 0 };
  store_data_ss = (vector signed short int){ 10, 20, 30, 40,
					     50, 60, 70, 80 };
  vec_ss_result1 = (vector signed short int){ 0, 0, 0, 0, 0, 0, 0, 0};

  address_ss = &vec_ss_result1[0];

  vec_xst_len (store_data_ss, address_ss, len);

  if (result_wrong_ss (vec_ss_expected1, vec_ss_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, ss result does not match expected result\n",
	      len);
       print_ss (vec_ss_expected1, vec_ss_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_us_expected1 = (vector unsigned short int){ 10, 20, 30, 40,
						  50, 60, 70, 80 };
  store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
					       50, 60, 70, 80 };
  vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};

  address_us = &vec_us_result1[0];

  vec_xst_len (store_data_us, address_us, len);

  if (result_wrong_us (vec_us_expected1, vec_us_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
	      len);
       print_us (vec_us_expected1, vec_us_result1);
#else
       abort();
#endif
    }

  len = 2;
  vec_us_expected1 = (vector unsigned short int){ 10, 0, 0, 0,
						  0, 0, 0, 0 };
  store_data_us = (vector unsigned short int){ 10, 20, 30, 40,
					       50, 60, 70, 80 };
  vec_us_result1 = (vector unsigned short int){ 0, 0, 0, 0, 0, 0, 0, 0};

  address_us = &vec_us_result1[0];

  vec_xst_len (store_data_us, address_us, len);

  if (result_wrong_us (vec_us_expected1, vec_us_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, us result does not match expected result\n",
	      len);
       print_us (vec_us_expected1, vec_us_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_si_expected1 = (vector signed int){ -30, -10, 0, 10 };
  store_data_si = (vector signed int){ -30, -10, 0, 10 };
  vec_si_result1 = (vector signed int){ 0, 0, 0, 0};

  address_si = &vec_si_result1[0];

  vec_xst_len (store_data_si, address_si, len);

  if (result_wrong_si (vec_si_expected1, vec_si_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
	      len);
       print_si (vec_si_expected1, vec_si_result1);
#else
       abort();
#endif
    }

  len = 8;
  vec_si_expected1 = (vector signed int){ -30, -10, 0, 0 };
  store_data_si = (vector signed int){ -30, -10, 0, 10 };
  vec_si_result1 = (vector signed int){ 0, 0, 0, 0};

  address_si = &vec_si_result1[0];

  vec_xst_len (store_data_si, address_si, len);

  if (result_wrong_si (vec_si_expected1, vec_si_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, si result does not match expected result\n",
	      len);
       print_si (vec_si_expected1, vec_si_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_sll_expected1 = (vector signed long long int){ -3000, 10000 };
  store_data_sll = (vector signed long long int){ -3000, 10000 };
  vec_sll_result1 = (vector signed long long int){ 0, 0};

  address_sll = (signed long long *)&vec_sll_result1[0];

  vec_xst_len (store_data_sll, address_sll, len);

  if (result_wrong_sll (vec_sll_expected1, vec_sll_result1) == TRUE)
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
	      len);
       print_sll (vec_sll_expected1, vec_sll_result1);
#else
       abort();
#endif
    }

  len = 8;
  vec_sll_expected1 = (vector signed long long int){ -3000, 0 };
  store_data_sll = (vector signed long long int){ -3000, 10000 };
  vec_sll_result1 = (vector signed long long int){ 0, 0};

  address_sll = (signed long long *)&vec_sll_result1[0];

  vec_xst_len (store_data_sll, address_sll, len);

  if (result_wrong_sll (vec_sll_expected1, vec_sll_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, sll result does not match expected result\n",
	      len);
       print_sll (vec_sll_expected1, vec_sll_result1);
#else
      abort();
#endif
    }

  len = 16;
  vec_ull_expected1 = (vector unsigned long long int){ 50000, 120000 };
  store_data_ull = (vector unsigned long long int){ 50000, 120000 };
  vec_ull_result1 = (vector unsigned long long int){ 0, 0};

  address_ull = (unsigned long long *) &vec_ull_result1[0];

  vec_xst_len (store_data_ull, address_ull, len);

  if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
	      len);
       print_ull (vec_ull_expected1, vec_ull_result1);
#else
       abort();
#endif
    }

  len = 8;
  vec_ull_expected1 = (vector unsigned long long int){ 50000, 0 };
  store_data_ull = (vector unsigned long long int){ 50000, 120000 };
  vec_ull_result1 = (vector unsigned long long int){ 0, 0};

  address_ull = (unsigned long long *) &vec_ull_result1[0];

  vec_xst_len (store_data_ull, address_ull, len);

  if (result_wrong_ull (vec_ull_expected1, vec_ull_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, ull result does not match expected result\n",
	      len);
       print_ull (vec_ull_expected1, vec_ull_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_s128_expected1 = (vector __int128_t){ 12345 };
  store_data_s128 = (vector __int128_t){ 12345 };

  vec_s128_result1[0] = 0;

  address_s128 = (__int128_t *)(&vec_s128_result1[0]);

  vec_xst_len (store_data_s128, address_s128, len);

  if (result_wrong_s128 (vec_s128_expected1, vec_s128_result1))
#ifdef DEBUG
    {
       printf("Error: vec_xst_len, len = %d, s128, result does not match expected result\n",
	      len);
       print_s128 (vec_s128_expected1, vec_s128_result1);
    }
#else
    abort();
#endif

  len = 16;
  vec_u128_expected1 = (vector __uint128_t){ 12345 };
  store_data_u128 = (vector __uint128_t){ 12345 };

  vec_u128_result1[0] = 0;

  address_u128 = (__int128_t *)(&vec_u128_result1[0]);

  vec_xst_len (store_data_u128, address_u128, len);

  if (result_wrong_u128 (vec_u128_expected1, vec_u128_result1))
    {
#ifdef DEBUG
      printf("Error: vec_xst_len, len = %d, u128, result does not match expected result\n", len);
      print_u128 (vec_u128_expected1, vec_u128_result1);
#else
      abort();
#endif
    }

  len = 16;
  vec_d_expected1 = (vector double){ 1., 2. };
  store_data_d = (vector double){ 1., 2. };
  vec_d_result1 = (vector double){ 0., 0. };

  address_d = (double *)(&vec_d_result1[0]);

  vec_xst_len (store_data_d, address_d, len);

  if (result_wrong_d (vec_d_expected1, vec_d_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
	      len);
       print_d (vec_d_expected1, vec_d_result1);
#else
       abort();
#endif
    }

  len = 8;
  vec_d_expected1 = (vector double){ 1., 0. };
  store_data_d = (vector double){ 1., 2. };
  vec_d_result1 = (vector double){ 0., 0. };

  address_d = (double *)(&vec_d_result1[0]);

  vec_xst_len (store_data_d, address_d, len);

  if (result_wrong_d (vec_d_expected1, vec_d_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, double, result does not match expected result\n",
	      len);
       print_d (vec_d_expected1, vec_d_result1);
#else
       abort();
#endif
    }

  len = 16;
  vec_f_expected1 = (vector float){ 1., 2., 3., 4. };
  store_data_f = (vector float){ 1., 2., 3., 4. };
  vec_f_result1 = (vector float){ 0., 0., 0., 0. };

  address_f = (float *)(&vec_f_result1[0]);

  vec_xst_len (store_data_f, address_f, len);

  if (result_wrong_f (vec_f_expected1, vec_f_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
	      len);
       print_f (vec_f_expected1, vec_f_result1);
#else
       abort();
#endif
    }

  len = 4;
  vec_f_expected1 = (vector float){ 1., 0., 0., 0. };
  store_data_f = (vector float){ 1., 2., 3., 4. };
  vec_f_result1 = (vector float){ 0., 0., 0., 0. };

  address_f = (float *)(&vec_f_result1[0]);

  vec_xst_len (store_data_f, address_f, len);

  if (result_wrong_f (vec_f_expected1, vec_f_result1))
    {
#ifdef DEBUG
       printf("Error: vec_xst_len, len = %d, float, result does not match expected result\n",
	      len);
       print_f (vec_f_expected1, vec_f_result1);
#else
       abort();
#endif
    }

  U128 u_temp;
  /* vec_xl_len() tests */
  for (i = 0; i < 100; i++)
    {
       data_c[i] = i;
       data_uc[i] = i + 1;
       data_ssi[i] = i + 10;
       data_usi[i] = i + 11;
       data_si[i] = i + 100;
       data_ui[i] = i + 101;
       data_sll[i] = i + 1000;
       data_ull[i] = i + 1001;
       data_f[i] = i + 100000.0;
       data_d[i] = i + 1000000.0;
       getU128 (&u_temp, i + 12800000);
       data_128[i] = u_temp.i2;
       getU128 (&u_temp, i + 12800001);
       data_u128[i] = u_temp.u2;
    }

  len = 16;
  vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
					  8, 9, 10, 11, 12, 13, 14, 15};
  vec_sc_result1 = vec_xl_len (data_c, len);

  for (i = 0; i < 16; i++)
    {
      if (vec_sc_result1[i] != vec_sc_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
	       len, i,  vec_sc_result1[i], i, vec_sc_expected1[i]);
#else
	abort ();
#endif
    }

  len = 12;

  vec_sc_expected1 = (vector signed char){0, 1, 2, 3, 4, 5, 6, 7,
					  8, 9, 10, 11, 0, 0, 0, 0};
  vec_sc_result1 = vec_xl_len (data_c, len);

  for (i = 0; i < 16; i++)
    {
      if (vec_sc_result1[i] != vec_sc_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
	       len, i,  vec_sc_result1[i], i, vec_sc_expected1[i]);
#else
        abort ();
#endif
    }

  len = 16;
  vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
					    10, 11, 12, 13, 14, 15, 16};
  vec_uc_result1 = vec_xl_len (data_uc, len);

  for (i = 0; i < 16; i++)
    {
      if (vec_uc_result1[i] != vec_uc_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
	       len, i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
#else
	abort ();
#endif
    }

  len = 12;
  vec_uc_expected1 = (vector unsigned char){1, 2, 3, 4, 5, 6, 7, 8, 9,
					    10, 11, 12, 0, 0, 0, 0};
  vec_uc_result1 = vec_xl_len (data_uc, len);

  for (i = 0; i < 16; i++)
    {
      if (vec_uc_result1[i] != vec_uc_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
	       len, i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 14, 15, 16, 17};

  vec_ss_result1 = vec_xl_len (data_ssi, len);

  for (i = 0; i < 8; i++)
    {
      if (vec_ss_result1[i] != vec_ss_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
	       len, i,  vec_ss_result1[i], i, vec_ss_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_ss_expected1 = (vector signed short){10, 11, 12, 13, 0, 0, 0, 0};

  vec_ss_result1 = vec_xl_len (data_ssi, len);

  for (i = 0; i < 8; i++)
    {
      if (vec_ss_result1[i] != vec_ss_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
	       len, i,  vec_ss_result1[i], i, vec_ss_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 15, 16, 17, 18};
  vec_us_result1 = vec_xl_len (data_usi, len);

  for (i = 0; i < 8; i++)
    {
      if (vec_us_result1[i] != vec_us_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
	       len, i,  vec_us_result1[i], i, vec_us_expected1[i]);
#else
	abort ();
#endif

    }

  len = 8;
  vec_us_expected1 = (vector unsigned short){11, 12, 13, 14, 0, 0, 0, 0};
  vec_us_result1 = vec_xl_len (data_usi, len);

  for (i = 0; i < 8; i++)
    {
      if (vec_us_result1[i] != vec_us_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
	       len, i,  vec_us_result1[i], i, vec_us_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_si_result1 = vec_xl_len (data_si, len);
  vec_si_expected1 = (vector int){100, 101, 102, 103};

  for (i = 0; i < 4; i++)
    {
      if (vec_si_result1[i] != vec_si_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
	       len, i,  vec_si_result1[i], i, vec_si_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_si_result1 = vec_xl_len (data_si, len);
  vec_si_expected1 = (vector int){100, 101, 0, 0};

  for (i = 0; i < 4; i++)
    {
      if (vec_si_result1[i] != vec_si_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
	       len, i,  vec_si_result1[i], i, vec_si_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ui_result1 = vec_xl_len (data_ui, len);
  vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};

  for (i = 0; i < 4; i++)
    {
      if (vec_ui_result1[i] != vec_ui_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
	       len, i,  vec_ui_result1[i], i, vec_ui_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_ui_result1 = vec_xl_len (data_ui, len);
  vec_ui_expected1 = (vector unsigned int){101, 102, 0, 0};

  for (i = 0; i < 4; i++)
    {
      if (vec_ui_result1[i] != vec_ui_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
	       len, i,  vec_ui_result1[i], i, vec_ui_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_sll_result1 = vec_xl_len (data_sll, len);
  vec_sll_expected1 = (vector signed long long){1000, 1001};

  for (i = 0; i < 2; i++)
    {
      if (vec_sll_result1[i] != vec_sll_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
	       len, i,  vec_sll_result1[i], i, vec_sll_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_sll_result1 = vec_xl_len (data_sll, len);
  vec_sll_expected1 = (vector signed long long){1000, 0};

  for (i = 0; i < 2; i++)
    {
      if (vec_sll_result1[i] != vec_sll_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
	       len, i,  vec_sll_result1[i], i, vec_sll_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ull_result1 = vec_xl_len (data_ull, len);
  vec_ull_expected1 = (vector unsigned long long){1001, 1002};

  for (i = 0; i < 2; i++)
    {
      if (vec_ull_result1[i] != vec_ull_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
	       len, i,  vec_ull_result1[i], i, vec_ull_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_ull_result1 = vec_xl_len (data_ull, len);
  vec_ull_expected1 = (vector unsigned long long){1001, 0};

  for (i = 0; i < 2; i++)
    {
      if (vec_ull_result1[i] != vec_ull_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
	       len, i,  vec_ull_result1[i], i, vec_ull_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_f_result1 = vec_xl_len (data_f, len);
  vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};

  for (i = 0; i < 4; i++)
    {
      if (vec_f_result1[i] != vec_f_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_f_result1[i], i, vec_f_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_f_result1 = vec_xl_len (data_f, len);
  vec_f_expected1 = (vector float){100000.0, 100001.0, 0.0, 0.0};

  for (i = 0; i < 4; i++)
    {
      if (vec_f_result1[i] != vec_f_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_f_result1[i], i, vec_f_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_d_result1 = vec_xl_len (data_d, len);
  vec_d_expected1 = (vector double){1000000.0, 1000001.0};

  for (i = 0; i < 2; i++)
    {
      if (vec_d_result1[i] != vec_d_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_d_result1[i], i, vec_d_expected1[i]);
#else
	abort ();
#endif
    }

  len = 8;
  vec_d_result1 = vec_xl_len (data_d, len);
  vec_d_expected1 = (vector double){1000000.0, 0.0};

  for (i = 0; i < 2; i++)
    {
      if (vec_d_result1[i] != vec_d_expected1[i])
#ifdef DEBUG
	printf("Error: vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_d_result1[i], i, vec_d_expected1[i]);
#else
	abort ();
#endif
    }

  getU128 (&u_temp, 12800000);
  vec_s128_expected1 = u_temp.i1;
  vec_s128_result1 = vec_xl_len (data_128, len);

  if (vec_s128_expected1[0] != vec_s128_result1[0])
    {
#ifdef DEBUG
      U128 u1, u2;
      u1.i1 = vec_s128_result1;
      u2.i1 = vec_s128_expected1;
      printf ("Error: vec_xl_len(), len = %d,"
	      "vec_s128_result1[0] = %llx %llx; ",
	      len, u1.d1, u1.d2);
      printf ("vec_s128_expected1[0] = %llx %llx\n", u2.d1, u2.d2);
#else
       abort ();
#endif
    }

  vec_u128_result1 = vec_xl_len (data_u128, len);
  getU128 (&u_temp, 12800001);
  vec_u128_expected1 = u_temp.u1;
  if (vec_u128_expected1[0] != vec_u128_result1[0])
#ifdef DEBUG
    {
      U128 u1, u2;
      u1.u1 = vec_u128_result1;
      u2.u1 = vec_u128_expected1;
      printf ("Error: vec_xl_len(), len = %d,"
	      "vec_u128_result1[0] = %llx %llx; ",
	      len, u1.d1, u1.d2);
      printf ("vec_u128_expected1[0] = %llx %llx\n", u2.d1, u2.d2);
    }
#else
    abort ();
#endif

    /* Tests to ensure the vec_xl_len() is properly optimized with a pre
       and post data initialization is done.  */

  len = 16;

  vec_sc_expected1 = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
					   0, 0, 0, 0, 0, 0, 0, 0 };

  input_c = (vector signed char){ 1, 2, 3, 4, 5, 6, 7, 8,
				  0, 0, 0, 0, 0, 0, 0, 0 };
  vec_sc_result1 = vec_xl_len (&input_c[0], len);
  input_c = (vector signed char){ 9, 10, 11, 12, 13, 14, 15, 16,
				  17, 18, 19, 20, 21, 22, 23, 24 };
  
  for (i = 0; i < 16; i++)
    {
      if (vec_sc_result1[i] != vec_sc_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sc_result1[%d] = %d; vec_sc_expected1[%d] = %d\n",
	       len, i,  vec_sc_result1[i], i, vec_sc_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_uc_expected1 = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
					     10, 11, 12, 13, 14, 15, 16 };
  input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
				   10, 11, 12, 13, 14, 15, 16 };
  vec_uc_result1 = vec_xl_len (&input_uc[0], len);
  input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
				     17, 18, 19, 20, 21, 22, 23, 24 };

  for (i = 0; i < 16; i++)
    {
      if (vec_uc_result1[i] != vec_uc_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
	       len, i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ss_expected1 = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
  input_ssi = (vector signed short){ 10, 11, 12, 13, 14, 15, 16, 17 };
  vec_ss_result1 = vec_xl_len (&input_ssi[0], len);
  input_ssi = (vector signed short){ 14, 15, 16, 17, 18, 19, 20, 21 };

  for (i = 0; i < 8; i++)
    {
      if (vec_ss_result1[i] != vec_ss_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ss_result1[%d] = %d; vec_ss_expected1[%d] = %d\n",
	       len, i,  vec_ss_result1[i], i, vec_ss_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_us_expected1 = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
  input_usi = (vector unsigned short){ 11, 12, 13, 14, 15, 16, 17, 18 };
  vec_us_result1 = vec_xl_len (&input_usi[0], len);
  input_usi = (vector unsigned short){ 15, 16, 17, 18, 19, 20, 21, 22 };

  for (i = 0; i < 8; i++)
    {
      if (vec_us_result1[i] != vec_us_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_us_result1[%d] = %d; vec_us_expected1[%d] = %d\n",
	       len, i,  vec_us_result1[i], i, vec_us_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_si_expected1 = (vector int){ 100, 101, 102, 103 };
  input_si = (vector int){ 100, 101, 102, 103 };
  vec_si_result1 = vec_xl_len (&input_si[0], len);
  input_si = (vector int){ 102, 103, 104, 105 };

  for (i = 0; i < 4; i++)
    {
      if (vec_si_result1[i] != vec_si_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_si_result1[%d] = %d; vec_si_expected1[%d] = %d\n",
	       len, i,  vec_si_result1[i], i, vec_si_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ui_expected1 = (vector unsigned int){101, 102, 103, 104};
  input_ui = (vector unsigned int){101, 102, 103, 104};
  vec_ui_result1 = vec_xl_len (&input_ui[0], len);
  input_ui = (vector unsigned int){ 103, 104, 105, 106 };

  for (i = 0; i < 4; i++)
    {
      if (vec_ui_result1[i] != vec_ui_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ui_result1[%d] = %d; vec_ui_expected1[%d] = %d\n",
	       len, i,  vec_ui_result1[i], i, vec_ui_expected1[i]);
#else
	abort ();
#endif
    }

#if 1  
  len = 16;
  vec_sll_expected1 = (vector signed long long){1000, 1001};
  input_sll = (vector signed long long ){1000, 1001};
  vec_sll_result1 = vec_xl_len ((signed long long int *)&input_sll[0], len);
  input_sll = (vector signed long long){1001, 1002};

  for (i = 0; i < 2; i++)
    {
      if (vec_sll_result1[i] != vec_sll_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_sll_result1[%d] = %lld; vec_sll_expected1[%d] = %lld\n",
	       len, i,  vec_sll_result1[i], i, vec_sll_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_ull_expected1 = (vector unsigned long long int){1001, 1002};
  input_ull = (vector unsigned long long int){1001, 1002};
  vec_ull_result1 = vec_xl_len ((unsigned long long int *)&input_ull[0], len);
  input_ull = (vector unsigned long long int){1002, 1003};

  for (i = 0; i < 2; i++)
    {
      if (vec_ull_result1[i] != vec_ull_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_ull_result1[%d] = %lld; vec_ull_expected1[%d] = %lld\n",
	       len, i,  vec_ull_result1[i], i, vec_ull_expected1[i]);
#else
	abort ();
#endif
    }
#endif

  
  len = 16;
  vec_f_expected1 = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
  input_f = (vector float){100000.0, 100001.0, 100002.0, 100003.0};
  vec_f_result1 = vec_xl_len (&input_f[0], len);
  input_f = (vector float){100001.0, 100002.0, 100003.0, 100004.0};

  for (i = 0; i < 4; i++)
    {
      if (vec_f_result1[i] != vec_f_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_f_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_f_result1[i], i, vec_f_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_d_expected1 = (vector double){1000000.0, 1000001.0};
  input_d = (vector double){1000000.0, 1000001.0};
  vec_d_result1 = vec_xl_len (&input_d[0], len);
  input_d = (vector double){1000001.0, 1000002.0};

  for (i = 0; i < 2; i++)
    {
      if (vec_d_result1[i] != vec_d_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_d_result1[%d] = %f; vec_f_expected1[%d] = %f\n",
	       len, i,  vec_d_result1[i], i, vec_d_expected1[i]);
#else
	abort ();
#endif
    }

  len = 16;
  vec_s128_expected1 = (vector __int128_t){12800000};
  input_128 = (vector __int128_t){12800000};
  vec_s128_result1 = vec_xl_len (&input_128[0], len);
  input_128 = (vector __int128_t){12345678};

  if (vec_s128_expected1[0] != vec_s128_result1[0])
    {
#ifdef DEBUG
       printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_s128_result1[0] = %lld %llu; ",
	      len, vec_s128_result1[0] >> 64,
	      vec_s128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
       printf("vec_s128_expected1[0] = %lld %llu\n",
	      vec_s128_expected1[0] >> 64,
	      vec_s128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
#else
       abort ();
#endif
    }

  len = 16;
  vec_u128_expected1 = (vector __uint128_t){12800001};
  input_u128 = (vector __uint128_t){12800001};
  vec_u128_result1 = vec_xl_len (&input_u128[0], len);
  input_u128 = (vector __uint128_t){98765432};

  if (vec_u128_expected1[0] != vec_u128_result1[0])
#ifdef DEBUG
    {
       printf("Error: pre/post initialzation vec_xl_len(), len = %d, vec_u128_result1[0] = %lld; ",
	      len, vec_u128_result1[0] >> 64,
	      vec_u128_result1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
       printf("vec_u128_expected1[0] = %lld\n",
	      vec_u128_expected1[0] >> 64,
	      vec_u128_expected1[0] & (__int128_t)0xFFFFFFFFFFFFFFFF);
    }
#else
    abort ();
#endif

    /* Tests to ensure the vec_xl_len_r() is properly optimized with a pre
       and post data initialization is done.  */

  len = 16;
#if __LITTLE_ENDIAN__
  vec_uc_expected1 = (vector unsigned char){16, 15, 14, 13, 12, 11, 10, 9,
					    8,	7,  6,	5,  4,	3,  2,	1};
#else
  vec_uc_expected1 = (vector unsigned char){1, 2,  3,  4,  5,  6,  7,  8,
					    9, 10, 11, 12, 13, 14, 15, 16};
#endif
  input_uc = (vector unsigned char){ 1, 2, 3, 4, 5, 6, 7, 8, 9,
				   10, 11, 12, 13, 14, 15, 16 };
  vec_uc_result1 = vec_xl_len_r (&input_uc[0], len);
  input_uc = (vector unsigned char){ 10, 11, 12, 13, 14, 15, 16,
				     17, 18, 19, 20, 21, 22, 23, 24 };

  for (i = 0; i < 16; i++)
    {
      if (vec_uc_result1[i] != vec_uc_expected1[i])
#ifdef DEBUG
	printf("Error: pre/post initialzation vec_xl_len_r(), len = %d, vec_uc_result1[%d] = %d; vec_uc_expected1[%d] = %d\n",
	       len, i,  vec_uc_result1[i], i, vec_uc_expected1[i]);
#else
	abort ();
#endif
    }

}